minder-cli 0.3.8__tar.gz → 0.4.1__tar.gz

{minder_cli-0.3.8 → minder_cli-0.4.1}/.gitignore

@@ -9,4 +9,6 @@ __pycache__
 ref
 .mcp.json
 .vscode/mcp.json
-default.profraw
+default.profraw
+node_modules
+.astro

{minder_cli-0.3.8 → minder_cli-0.4.1}/PKG-INFO

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

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

@@ -276,6 +276,7 @@ class ClientRepositoryResolveRequest(BaseModel):
 class ClientRepositoryResolvePayload(TypedDict):
     repository: RepositoryPayload
     created: bool
+    last_sync: dict[str, Any] | None
 
 
 class GraphSyncNodeRefRequest(BaseModel):
@@ -314,7 +315,9 @@ class GraphSyncRequest(BaseModel):
     repo_path: str | None = None
     branch: str | None = None
     diff_base: str | None = None
+    changed_files: list[str] = Field(default_factory=list)
     deleted_files: list[str] = Field(default_factory=list)
+    commit_hash: str | None = None
     sync_metadata: dict[str, Any] = Field(default_factory=dict)
     nodes: list[GraphSyncNodeRequest] = Field(default_factory=list)
     edges: list[GraphSyncEdgeRequest] = Field(default_factory=list)

{minder_cli-0.3.8 → minder_cli-0.4.1}/src/minder/application/admin/use_cases.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import uuid
 from collections import Counter
 from datetime import UTC, datetime
@@ -78,6 +79,8 @@ DASHBOARD_TOOL_SCOPE_PRESETS: dict[str, list[str]] = {
     ],
 }
 
+logger = logging.getLogger(__name__)
+
 
 class AdminConsoleUseCases:
     def __init__(
@@ -743,7 +746,7 @@ class AdminConsoleUseCases:
             )
             if existing_remote != normalized_url:
                 updates["repo_url"] = normalized_url
-            if str(getattr(repository, "state_path", "") or "") != state_path:
+            if not str(getattr(repository, "state_path", "") or "").strip() and state_path:
                 updates["state_path"] = state_path
             if (
                 normalized_branch
@@ -760,6 +763,7 @@ class AdminConsoleUseCases:
         return {
             "repository": self.serialize_repository(repository),
             "created": created,
+            "last_sync": self._repository_last_sync(repository),
         }
 
     @staticmethod
@@ -810,9 +814,33 @@ class AdminConsoleUseCases:
         deleted_nodes = 0
         nodes_upserted = 0
         edges_upserted = 0
-
+        
+        # --- Check for redundant sync using commit_hash ---
+        relationships = dict(getattr(repository, "relationships", {}) or {})
+        graph_sync = dict(relationships.get("graph_sync", {}) or {})
+        last_sync = dict(graph_sync.get("last_sync", {}) or {})
+        
+        if (
+            payload.commit_hash 
+            and payload.commit_hash == last_sync.get("commit_hash")
+            and not payload.nodes 
+            and not payload.edges
+            and not payload.deleted_files
+        ):
+            return {
+                "repo_id": str(repo_id),
+                "repository_name": repo_name,
+                "payload_version": payload.payload_version,
+                "source": payload.source,
+                "branch": branch,
+                "deleted_nodes": 0,
+                "nodes_upserted": 0,
+                "edges_upserted": 0,
+                "accepted_at": accepted_at,
+            }
+ 
         # --- Scoped deletion: prune stale nodes for changed/deleted files ---
-        changed_files = payload.sync_metadata.get("changed_files", [])
+        changed_files = payload.changed_files
         paths_to_prune: set[str] = set(payload.deleted_files)
         if isinstance(changed_files, list):
             paths_to_prune.update(
@@ -835,7 +863,7 @@ class AdminConsoleUseCases:
                 )
             else:
                 for graph_node in await self._graph_store.list_nodes():
-                    metadata = dict(getattr(graph_node, "node_metadata", {}) or {})
+                    metadata = dict(graph_node.extra_metadata or {})
                     if metadata.get("repo_id") != str(repo_id):
                         continue
                     if branch is not None and metadata.get("branch") not in {
@@ -851,6 +879,13 @@ class AdminConsoleUseCases:
         # --- Upsert nodes with proper repo/branch scope (v2) ---
         _branch = branch or ""
         _repo_id_str = str(repo_id)
+        
+        # We strip large collections from sync_metadata before broadcasting to nodes
+        _filtered_sync_meta = {
+            k: v for k, v in payload.sync_metadata.items()
+            if k not in {"changed_files", "deleted_files"}
+        }
+
         _common_meta = {
             "repo_id": _repo_id_str,
             "repository_name": repo_name,
@@ -860,20 +895,8 @@ class AdminConsoleUseCases:
             "branch": _branch,
             "repo_path": payload.repo_path,
             "diff_base": payload.diff_base,
-            **payload.sync_metadata,
+            **_filtered_sync_meta,
         }
-
-        for node in payload.nodes:
-            persisted = await self._graph_store.upsert_node(
-                node.node_type,
-                node.name,
-                metadata={**_common_meta, **node.metadata},
-                repo_id=_repo_id_str,
-                branch=_branch,
-            )
-            node_ids[(node.node_type, node.name)] = persisted.id
-            nodes_upserted += 1
-
         _edge_common_meta = {
             "repo_id": _repo_id_str,
             "repository_name": repo_name,
@@ -884,40 +907,54 @@ class AdminConsoleUseCases:
             "repo_path": payload.repo_path,
         }
 
+        # --- Bulk upsert nodes ---
+        # Use a dict to deduplicate nodes by (type, name)
+        deduped_nodes: dict[tuple[str, str], dict[str, Any]] = {}
+        
+        for node in payload.nodes:
+            key = (node.node_type, node.name)
+            deduped_nodes[key] = {
+                "node_type": node.node_type,
+                "name": node.name,
+                "metadata": {**_common_meta, **node.metadata},
+            }
+        
+        # Also need to collect nodes mentioned in edges that might not be in payload.nodes
         for edge in payload.edges:
-            source_key = (edge.source.node_type, edge.source.name)
-            target_key = (edge.target.node_type, edge.target.name)
-
-            if source_key not in node_ids:
-                source_node = await self._graph_store.upsert_node(
-                    edge.source.node_type,
-                    edge.source.name,
-                    metadata=_edge_common_meta,
-                    repo_id=_repo_id_str,
-                    branch=_branch,
-                )
-                node_ids[source_key] = source_node.id
-                nodes_upserted += 1
-
-            if target_key not in node_ids:
-                target_node = await self._graph_store.upsert_node(
-                    edge.target.node_type,
-                    edge.target.name,
-                    metadata=_edge_common_meta,
-                    repo_id=_repo_id_str,
-                    branch=_branch,
-                )
-                node_ids[target_key] = target_node.id
-                nodes_upserted += 1
-
-            await self._graph_store.upsert_edge(
-                source_id=node_ids[source_key],
-                target_id=node_ids[target_key],
-                relation=edge.relation,
-                weight=edge.weight,
-                repo_id=_repo_id_str,
-            )
-            edges_upserted += 1
+            for side in [edge.source, edge.target]:
+                key = (side.node_type, side.name)
+                if key not in deduped_nodes:
+                    deduped_nodes[key] = {
+                        "node_type": side.node_type,
+                        "name": side.name,
+                        "metadata": _edge_common_meta,
+                    }
+        
+        node_ids = await self._graph_store.bulk_upsert_nodes(
+            list(deduped_nodes.values()),
+            repo_id=_repo_id_str,
+            branch=_branch,
+        )
+        nodes_upserted = len(deduped_nodes)
+
+        # --- Bulk upsert edges ---
+        deduped_edges: dict[tuple[uuid.UUID, uuid.UUID, str], dict[str, Any]] = {}
+        for edge in payload.edges:
+            source_id = node_ids.get((edge.source.node_type, edge.source.name))
+            target_id = node_ids.get((edge.target.node_type, edge.target.name))
+            if source_id and target_id:
+                edge_key = (source_id, target_id, edge.relation)
+                deduped_edges[edge_key] = {
+                    "source_id": source_id,
+                    "target_id": target_id,
+                    "relation": edge.relation,
+                    "weight": edge.weight,
+                }
+        
+        edges_upserted = await self._graph_store.bulk_upsert_edges(
+            list(deduped_edges.values()),
+            repo_id=_repo_id_str,
+        )
 
         # --- Update repository: tracked_branches + graph_sync metadata ---
         relationships = dict(getattr(repository, "relationships", {}) or {})
@@ -929,12 +966,12 @@ class AdminConsoleUseCases:
             "repo_remote": repo_remote,
             "diff_base": payload.diff_base,
             "deleted_files": payload.deleted_files,
+            "commit_hash": payload.commit_hash,
             "deleted_nodes": deleted_nodes,
             "nodes_upserted": nodes_upserted,
             "edges_upserted": edges_upserted,
             "accepted_at": accepted_at,
         }
-        graph_sync = dict(relationships.get("graph_sync", {}) or {})
         graph_sync["last_sync"] = graph_sync_state
         graph_sync.update(graph_sync_state)
         branch_registry = dict(graph_sync.get("branches", {}) or {})
@@ -983,6 +1020,9 @@ class AdminConsoleUseCases:
             tracked_branches=raw_branches,
         )
 
+        # Auto-prune stale branches that are no longer tracked
+        await self.prune_repository_stale_data(repo_id)
+
         return {
             "repo_id": str(repo_id),
             "repository_name": repo_name,
@@ -1031,35 +1071,82 @@ class AdminConsoleUseCases:
 
         repo_nodes = await self._repository_graph_nodes(repository, branch=branch)
         counts = Counter(str(getattr(node, "node_type", "")) for node in repo_nodes)
-        repo_node_ids = {str(getattr(node, "id")) for node in repo_nodes}
-        services = [
-            node
-            for node in repo_nodes
-            if str(getattr(node, "node_type", "")) == "service"
-        ]
+        # 1. Fetch all edges for the repo
+        repo_edges = await self._graph_store.list_edges_by_scope(repo_id=str(repo_id))
+        
+        # 2. Build map of nodes and containment map (parent map)
+        node_id_to_node = {str(getattr(node, "id")): node for node in repo_nodes}
+        parent_map: dict[str, str] = {} # child_id -> parent_id
+        for edge in repo_edges:
+            if edge.relation == "contains":
+                parent_map[str(edge.target_id)] = str(edge.source_id)
+        
+        # 3. Identify dependency relations
+        dependency_relations = {"depends_on", "uses_external_service", "calls", "imports"}
+        
+        # 4. Find all dependency edges and group by high-level owner
+        # owner_id -> set of target info
+        owner_to_deps: dict[str, set[tuple[str, str, str]]] = {} 
+        
+        high_level_types = {"service", "repository", "module", "controller"}
+        
+        for edge in repo_edges:
+            if edge.relation not in dependency_relations:
+                continue
+            
+            source_id = str(edge.source_id)
+            target_id = str(edge.target_id)
+            
+            # Find high-level owner for the source node
+            curr_id = source_id
+            owner_node = None
+            
+            # Search upwards for a high-level owner
+            visited = {curr_id}
+            while curr_id in node_id_to_node:
+                node = node_id_to_node[curr_id]
+                if str(getattr(node, "node_type", "")) in high_level_types:
+                    owner_node = node
+                    break
+                
+                parent_id = parent_map.get(curr_id)
+                if not parent_id or parent_id in visited:
+                    break
+                curr_id = parent_id
+                visited.add(curr_id)
+            
+            if not owner_node:
+                continue
+                
+            # Get target info
+            target_node = node_id_to_node.get(target_id)
+            if not target_node:
+                continue
+            
+            owner_id = str(owner_node.id)
+            if owner_id not in owner_to_deps:
+                owner_to_deps[owner_id] = set()
+            
+            owner_to_deps[owner_id].add((
+                target_id,
+                str(getattr(target_node, "name", "")),
+                str(getattr(target_node, "node_type", "")),
+            ))
+
+        # 5. Format the results
         dependencies: list[dict[str, Any]] = []
-        for service in services:
-            neighbors = await self._graph_store.get_neighbors(
-                getattr(service, "id"),
-                direction="out",
-                relation="depends_on",
-            )
-            targets = [
-                {
-                    "id": str(getattr(neighbor, "id")),
-                    "name": str(getattr(neighbor, "name", "")),
-                    "node_type": str(getattr(neighbor, "node_type", "")),
-                }
-                for neighbor in neighbors
-                if str(getattr(neighbor, "id")) in repo_node_ids
+        for owner_id, targets in owner_to_deps.items():
+            owner_node = node_id_to_node[owner_id]
+            depends_on_items: list[dict[str, str]] = [
+                {"id": tid, "name": tname, "node_type": ttype}
+                for tid, tname, ttype in targets
             ]
-            if targets:
-                dependencies.append(
-                    {
-                        "service": str(getattr(service, "name", "")),
-                        "depends_on": sorted(targets, key=lambda item: item["name"]),
-                    }
-                )
+            dependencies.append({
+                "service": str(getattr(owner_node, "name", "")),
+                "source_type": str(getattr(owner_node, "node_type", "")),
+                "depends_on": sorted(depends_on_items, key=lambda item: item["name"]),
+            })
+        dependencies.sort(key=lambda item: str(item["service"]))
 
         return {
             "repository": repository_payload,
@@ -1071,13 +1158,19 @@ class AdminConsoleUseCases:
             "node_count": len(repo_nodes),
             "counts_by_type": dict(counts),
             "routes": self._serialize_repo_graph_nodes(
-                repo_nodes, allowed_types={"route"}, limit=12
+                repo_nodes, 
+                allowed_types={"route", "api_endpoint", "websocket_endpoint"}, 
+                limit=50
             ),
             "todos": self._serialize_repo_graph_nodes(
-                repo_nodes, allowed_types={"todo"}, limit=12
+                repo_nodes, 
+                allowed_types={"todo"}, 
+                limit=50
             ),
             "external_services": self._serialize_repo_graph_nodes(
-                repo_nodes, allowed_types={"external_service_api"}, limit=12
+                repo_nodes, 
+                allowed_types={"external_service_api", "external_service"}, 
+                limit=50
             ),
             "dependencies": dependencies,
         }
@@ -1087,6 +1180,8 @@ class AdminConsoleUseCases:
         *,
         repo_id: uuid.UUID,
         branch: str | None = None,
+        node_types: list[str] | None = None,
+        limit: int | None = 1000,
     ) -> RepositoryGraphMapPayload:
         repository = await self._store.get_repository_by_id(repo_id)
         if repository is None:
@@ -1124,7 +1219,41 @@ class AdminConsoleUseCases:
             repo_name=getattr(repository, "repo_name", None),
             repo_path=self._repository_root_path(repository),
             branch=effective_branch,
+            node_types=node_types,
         )
+
+        total_nodes = len(repo_nodes)
+        total_edges = len(repo_edges)
+
+        # If too many nodes, we limit the return set to prevent browser freeze
+        # We prioritize nodes by their 'importance' (node_type)
+        if limit and len(repo_nodes) > limit:
+            # Simple heuristic: prioritize non-file nodes first (higher level abstraction)
+            type_priority = {
+                "repository": 0,
+                "service": 1,
+                "module": 2,
+                "controller": 3,
+                "route": 4,
+                "api_endpoint": 5,
+                "websocket_endpoint": 6,
+                "mq_topic": 7,
+                "external_service_api": 8,
+                "workflow": 9,
+                "folder": 10,
+                "file": 11,
+                "todo": 12,
+                "class": 20,
+                "interface": 21,
+                "abstract_class": 22,
+                "function": 23,
+            }
+            repo_nodes.sort(key=lambda n: type_priority.get(getattr(n, "node_type", ""), 15))
+            repo_nodes = repo_nodes[:limit]
+            
+            # Filter edges to only those connecting remaining nodes
+            node_ids = {n.id for n in repo_nodes}
+            repo_edges = [e for e in repo_edges if e.source_id in node_ids and e.target_id in node_ids]
         node_counts = Counter(
             str(getattr(node, "node_type", "")) for node in repo_nodes
         )
@@ -1139,14 +1268,92 @@ class AdminConsoleUseCases:
             "branch_links": branch_links["links"],
             "nodes": [self._serialize_graph_node(node) for node in repo_nodes],
             "edges": [self._serialize_graph_edge(edge) for edge in repo_edges],
+            "summary": {
+                "node_count": total_nodes,
+                "edge_count": total_edges,
+                "returned_node_count": len(repo_nodes),
+                "returned_edge_count": len(repo_edges),
+                "counts_by_type": dict(node_counts),
+                "counts_by_relation": dict(relation_counts),
+            },
+        }
+
+    async def get_repository_node_neighborhood(
+        self,
+        *,
+        repo_id: uuid.UUID,
+        node_id: uuid.UUID,
+        depth: int = 4,
+        limit: int = 200,
+    ) -> RepositoryGraphMapPayload:
+        """Fetch a subgraph around a specific node with limited depth/count."""
+        repository = await self._store.get_repository_by_id(repo_id)
+        if repository is None:
+            raise LookupError("Repository not found")
+
+        if self._graph_store is None:
+            raise RuntimeError("Graph store is not configured")
+
+        repo_nodes, repo_edges = await self._graph_store.get_neighborhood(
+            node_id=node_id,
+            max_depth=depth,
+            max_nodes=limit,
+        )
+
+        repository_payload = self.serialize_repository(repository)
+        
+        # Calculate summary
+        node_counts = Counter(
+            str(getattr(node, "node_type", "")) for node in repo_nodes
+        )
+        relation_counts = Counter(
+            str(getattr(edge, "relation", "")) for edge in repo_edges
+        )
+
+        return {
+            "repository": repository_payload,
+            "graph_available": bool(repo_nodes),
+            "branch": getattr(repo_nodes[0], "branch", None) if repo_nodes else None,
+            "branch_state": None,
+            "branch_links": [],
+            "nodes": [self._serialize_graph_node(node) for node in repo_nodes],
+            "edges": [self._serialize_graph_edge(edge) for edge in repo_edges],
             "summary": {
                 "node_count": len(repo_nodes),
                 "edge_count": len(repo_edges),
+                "returned_node_count": len(repo_nodes),
+                "returned_edge_count": len(repo_edges),
                 "counts_by_type": dict(node_counts),
                 "counts_by_relation": dict(relation_counts),
             },
         }
 
+    async def prune_repository_stale_data(self, repo_id: uuid.UUID) -> dict[str, Any]:
+        """Delete graph data for branches that are no longer tracked."""
+        if self._graph_store is None:
+            return {"deleted": 0}
+        
+        repository = await self._store.get_repository_by_id(repo_id)
+        if not repository:
+            return {"deleted": 0}
+
+        tracked = set(getattr(repository, "tracked_branches", []) or [])
+        if not tracked:
+            return {"deleted": 0}
+
+        repo_id_str = str(repo_id)
+        branches_in_graph = await self._graph_store.list_repo_branches(repo_id_str)
+        
+        deleted_total = 0
+        for branch in branches_in_graph:
+            if branch not in tracked:
+                logger.info(f"Pruning stale branch data: {repo_id_str}/{branch}")
+                deleted_total += await self._graph_store.delete_nodes_by_scope(
+                    repo_id=repo_id_str, branch=branch
+                )
+        
+        return {"deleted": deleted_total}
+
     async def search_repository_graph(
         self,
         *,
@@ -1599,7 +1806,7 @@ class AdminConsoleUseCases:
 
     @staticmethod
     def _serialize_graph_node(node: Any) -> RepositoryGraphNodePayload:
-        metadata = dict(getattr(node, "node_metadata", {}) or {})
+        metadata = dict(node.extra_metadata or {})
         return {
             "id": str(getattr(node, "id")),
             "node_type": str(getattr(node, "node_type", "")),
@@ -1632,7 +1839,7 @@ class AdminConsoleUseCases:
         filtered.sort(
             key=lambda node: (
                 str(getattr(node, "node_type", "")),
-                str(dict(getattr(node, "node_metadata", {}) or {}).get("path", "")),
+                str((node.extra_metadata or {}).get("path", "")),
                 str(getattr(node, "name", "")),
             )
         )

{minder_cli-0.3.8 → minder_cli-0.4.1}/src/minder/graph/nodes/reasoning.py

@@ -78,6 +78,14 @@ class ReasoningNode:
                     else "No repository context found."
                 ),
                 "correction_required": retry_reason,
+                "chat_history": (
+                    "\n".join(
+                        f"{'User' if m.get('role') == 'user' else 'Assistant'}: {m.get('content')}"
+                        for m in (state.chat_history or [])
+                    )
+                    if state.chat_history
+                    else "No conversation history."
+                ),
             },
             defaults=prompt_defaults,
         )

{minder_cli-0.3.8 → minder_cli-0.4.1}/src/minder/graph/nodes/workflow_planner.py

@@ -174,8 +174,8 @@ class WorkflowPlannerNode:
             for n in service_nodes
             if n.name == repo_name
             or (
-                hasattr(n, "node_metadata")
-                and n.node_metadata.get("path", "").startswith(repo_path)
+                hasattr(n, "extra_metadata")
+                and (n.extra_metadata or {}).get("path", "").startswith(repo_path)
             )
         ]
 

{minder_cli-0.3.8 → minder_cli-0.4.1}/src/minder/models/graph.py

@@ -20,6 +20,7 @@ from typing import Any
 
 from pydantic import Field
 from sqlalchemy import DateTime, Float, JSON, String, UUID, UniqueConstraint, func
+from sqlalchemy.ext.mutable import MutableDict
 from sqlalchemy.orm import Mapped, mapped_column
 
 from .base import Base, BaseModelMeta
@@ -36,7 +37,7 @@ class GraphNodeSchema(BaseModelMeta):
     branch: str = ""
     node_type: str  # module | file | service | owner | route | api_endpoint | websocket_endpoint | mq_topic | …
     name: str
-    metadata: dict[str, Any] = Field(default_factory=dict)
+    extra_metadata: dict[str, Any] = Field(default_factory=dict)
     created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
 
 
@@ -80,7 +81,7 @@ class GraphNode(Base):
     branch: Mapped[str] = mapped_column(String, index=True, default="", server_default="")
     node_type: Mapped[str] = mapped_column(String, index=True)
     name: Mapped[str] = mapped_column(String, index=True)
-    node_metadata: Mapped[dict] = mapped_column("metadata", JSON, default=dict)
+    extra_metadata: Mapped[dict] = mapped_column("metadata", MutableDict.as_mutable(JSON), default=dict)
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True), server_default=func.now()
     )