minder-cli 0.2.0__py3-none-any.whl

minder/store/repo_state.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+class RepoStateStore:
+    def __init__(self, state_dir_name: str = ".minder") -> None:
+        self._state_dir_name = state_dir_name
+
+    async def read_all(self, repo_path: str) -> dict[str, Any]:
+        state_dir = self._ensure_state_dir(repo_path)
+        return {
+            "workflow": self._read_json(state_dir / "workflow.json", default={}),
+            "context": self._read_json(state_dir / "context.json", default={}),
+            "relationships": self._read_json(state_dir / "relationships.json", default={}),
+            "artifacts": self._read_artifacts(state_dir / "artifacts"),
+        }
+
+    async def write_workflow_state(self, repo_path: str, payload: dict[str, Any]) -> None:
+        self._write_json(self._ensure_state_dir(repo_path) / "workflow.json", payload)
+
+    async def write_context(self, repo_path: str, payload: dict[str, Any]) -> None:
+        self._write_json(self._ensure_state_dir(repo_path) / "context.json", payload)
+
+    async def write_relationships(self, repo_path: str, payload: dict[str, Any]) -> None:
+        self._write_json(self._ensure_state_dir(repo_path) / "relationships.json", payload)
+
+    async def write_artifact(self, repo_path: str, name: str, content: str) -> None:
+        artifacts_dir = self._ensure_state_dir(repo_path) / "artifacts"
+        artifacts_dir.mkdir(parents=True, exist_ok=True)
+        (artifacts_dir / name).write_text(content, encoding="utf-8")
+
+    def _ensure_state_dir(self, repo_path: str) -> Path:
+        state_dir = Path(repo_path) / self._state_dir_name
+        state_dir.mkdir(parents=True, exist_ok=True)
+        return state_dir
+
+    @staticmethod
+    def _read_json(path: Path, *, default: dict[str, Any]) -> dict[str, Any]:
+        if not path.exists():
+            return default
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    @staticmethod
+    def _write_json(path: Path, payload: dict[str, Any]) -> None:
+        path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+
+    @staticmethod
+    def _read_artifacts(path: Path) -> dict[str, str]:
+        if not path.exists():
+            return {}
+        return {
+            item.name: item.read_text(encoding="utf-8")
+            for item in sorted(path.iterdir())
+            if item.is_file()
+        }

minder/store/rule.py

@@ -0,0 +1,93 @@
+"""
+RuleStore — async SQLAlchemy CRUD for the Rule domain model.
+
+Supports filtering by scope and active flag.
+"""
+
+from __future__ import annotations
+
+import uuid
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+from sqlalchemy import delete, select, update
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+from minder.models import Base, Rule
+
+
+class RuleStore:
+    """Async store for :class:`~minder.models.Rule` entities."""
+
+    def __init__(self, db_url: str, echo: bool = False) -> None:
+        self._engine = create_async_engine(db_url, echo=echo)
+        self._session_factory = async_sessionmaker(
+            self._engine,
+            expire_on_commit=False,
+            class_=AsyncSession,
+        )
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def init_db(self) -> None:
+        async with self._engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+    async def dispose(self) -> None:
+        await self._engine.dispose()
+
+    @asynccontextmanager
+    async def _session(self) -> AsyncGenerator[AsyncSession, None]:
+        async with self._session_factory() as sess:
+            try:
+                yield sess
+                await sess.commit()
+            except Exception:
+                await sess.rollback()
+                raise
+
+    # ------------------------------------------------------------------
+    # CRUD
+    # ------------------------------------------------------------------
+
+    async def create_rule(self, **kwargs) -> Rule:
+        async with self._session() as sess:
+            rule = Rule(**kwargs)
+            sess.add(rule)
+            await sess.flush()
+            await sess.refresh(rule)
+            return rule
+
+    async def get_rule_by_id(self, rule_id: uuid.UUID) -> Rule | None:
+        async with self._session() as sess:
+            result = await sess.execute(select(Rule).where(Rule.id == rule_id))
+            return result.scalar_one_or_none()
+
+    async def list_rules(self) -> list[Rule]:
+        async with self._session() as sess:
+            result = await sess.execute(select(Rule))
+            return list(result.scalars().all())
+
+    async def list_by_scope(self, scope: str) -> list[Rule]:
+        """Return all rules matching the given scope."""
+        async with self._session() as sess:
+            result = await sess.execute(select(Rule).where(Rule.scope == scope))
+            return list(result.scalars().all())
+
+    async def list_active(self) -> list[Rule]:
+        """Return all active rules (active=True)."""
+        async with self._session() as sess:
+            result = await sess.execute(select(Rule).where(Rule.active.is_(True)))
+            return list(result.scalars().all())
+
+    async def update_rule(self, rule_id: uuid.UUID, **kwargs) -> Rule | None:
+        async with self._session() as sess:
+            await sess.execute(update(Rule).where(Rule.id == rule_id).values(**kwargs))
+            result = await sess.execute(select(Rule).where(Rule.id == rule_id))
+            return result.scalar_one_or_none()
+
+    async def delete_rule(self, rule_id: uuid.UUID) -> None:
+        async with self._session() as sess:
+            await sess.execute(delete(Rule).where(Rule.id == rule_id))

minder/store/vector.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import math
+import uuid
+from typing import Any
+
+from minder.store.interfaces import IVectorStore, IDocumentRepository, IErrorRepository
+
+
+class VectorStore(IVectorStore):
+    def __init__(self, document_store: IDocumentRepository, error_store: IErrorRepository) -> None:
+        self._document_store = document_store
+        self._error_store = error_store
+
+    async def upsert_document(
+        self,
+        doc_id: uuid.UUID,
+        embedding: list[float],
+        payload: dict[str, Any],
+    ) -> None:
+        """Not supported in Relational VectorStore."""
+        pass
+
+    async def delete_documents(self, doc_ids: list[uuid.UUID]) -> None:
+        """Not supported in Relational VectorStore."""
+        pass
+    
+    async def setup(self) -> None:
+        """No setup needed for Relational VectorStore."""
+        pass
+
+    async def search_documents(
+        self,
+        query_embedding: list[float],
+        *,
+        project: str | None = None,
+        doc_types: set[str] | None = None,
+        limit: int = 5,
+        score_threshold: float = 0.0,
+    ) -> list[dict[str, Any]]:
+        docs = await self._document_store.list_documents(project=project)
+        ranked: list[dict[str, Any]] = []
+        for doc in docs:
+            if doc_types is not None and doc.doc_type not in doc_types:
+                continue
+            embedding = doc.embedding if isinstance(doc.embedding, list) else None
+            if not embedding:
+                continue
+            score = self._cosine_similarity(query_embedding, embedding)
+            if score < score_threshold:
+                continue
+            ranked.append(
+                {
+                    "id": doc.id,
+                    "title": doc.title,
+                    "path": doc.source_path,
+                    "content": doc.content,
+                    "score": round(score, 4),
+                    "doc_type": doc.doc_type,
+                }
+            )
+        ranked.sort(key=lambda item: float(item["score"]), reverse=True)
+        return ranked[:limit]
+
+    async def search_errors(
+        self, query: str, *, limit: int = 5
+    ) -> list[dict[str, Any]]:
+        return await self._error_store.search_errors(query, limit=limit)
+
+    @staticmethod
+    def _cosine_similarity(left: list[float], right: list[float]) -> float:
+        if not left or not right or len(left) != len(right):
+            return 0.0
+        numerator = sum(a * b for a, b in zip(left, right, strict=False))
+        left_norm = math.sqrt(sum(value * value for value in left))
+        right_norm = math.sqrt(sum(value * value for value in right))
+        if left_norm == 0 or right_norm == 0:
+            return 0.0
+        return numerator / (left_norm * right_norm)

minder/tools/__init__.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .auth import AuthTools
+    from .ingest import IngestTools
+    from .memory import MemoryTools
+    from .query import QueryTools
+    from .repo_scanner import RepoScanner
+    from .search import SearchTools
+    from .session import SessionTools
+    from .workflow import WorkflowTools
+
+__all__ = [
+    "AuthTools",
+    "IngestTools",
+    "MemoryTools",
+    "QueryTools",
+    "RepoScanner",
+    "SearchTools",
+    "SessionTools",
+    "WorkflowTools",
+]
+
+_LAZY_EXPORTS: dict[str, tuple[str, str]] = {
+    "AuthTools": (".auth", "AuthTools"),
+    "IngestTools": (".ingest", "IngestTools"),
+    "MemoryTools": (".memory", "MemoryTools"),
+    "QueryTools": (".query", "QueryTools"),
+    "RepoScanner": (".repo_scanner", "RepoScanner"),
+    "SearchTools": (".search", "SearchTools"),
+    "SessionTools": (".session", "SessionTools"),
+    "WorkflowTools": (".workflow", "WorkflowTools"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    module_spec = _LAZY_EXPORTS.get(name)
+    if module_spec is None:
+        raise AttributeError(name)
+    module_name, symbol_name = module_spec
+    module = import_module(module_name, __name__)
+    value = getattr(module, symbol_name)
+    globals()[name] = value
+    return value

minder/tools/auth.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import uuid
+
+from minder.auth.service import AuthService
+from minder.store.interfaces import IOperationalStore
+
+
+class AuthTools:
+    def __init__(self, store: IOperationalStore, auth_service: AuthService) -> None:
+        self._store = store
+        self._auth = auth_service
+
+    async def minder_auth_login(self, api_key: str) -> dict[str, str]:
+        user = await self._auth.authenticate_api_key(api_key)
+        return {"token": self._auth.issue_jwt(user), "user_id": str(user.id)}
+
+    async def minder_auth_exchange_client_key(
+        self,
+        client_api_key: str,
+        *,
+        requested_scopes: list[str] | None = None,
+    ) -> dict[str, object]:
+        return await self._auth.exchange_client_api_key(
+            client_api_key,
+            requested_scopes=requested_scopes,
+        )
+
+    async def minder_auth_whoami(self, token: str) -> dict[str, str]:
+        user = await self._auth.get_user_from_jwt(token)
+        return {
+            "user_id": str(user.id),
+            "email": user.email,
+            "username": user.username,
+            "role": user.role,
+        }
+
+    async def minder_auth_manage(
+        self,
+        *,
+        actor_user_id: uuid.UUID,
+        action: str,
+    ) -> dict[str, object]:
+        actor = await self._store.get_user_by_id(actor_user_id)
+        if actor is None or actor.role != "admin":
+            raise PermissionError("Admin role required")
+        if action == "list_users":
+            users = await self._store.list_users(active_only=False)
+            return {
+                "users": [
+                    {
+                        "id": str(user.id),
+                        "email": user.email,
+                        "username": user.username,
+                        "role": user.role,
+                        "is_active": user.is_active,
+                    }
+                    for user in users
+                ]
+            }
+        raise ValueError(f"Unsupported auth manage action: {action}")
+
+    async def minder_auth_create_client(
+        self,
+        *,
+        actor_user_id: uuid.UUID,
+        name: str,
+        slug: str,
+        description: str = "",
+        tool_scopes: list[str] | None = None,
+        repo_scopes: list[str] | None = None,
+    ) -> dict[str, object]:
+        actor = await self._store.get_user_by_id(actor_user_id)
+        if actor is None or actor.role != "admin":
+            raise PermissionError("Admin role required")
+        client, client_api_key = await self._auth.register_client(
+            name=name,
+            slug=slug,
+            description=description,
+            created_by_user_id=actor_user_id,
+            tool_scopes=tool_scopes,
+            repo_scopes=repo_scopes,
+        )
+        return {
+            "client": {
+                "id": str(client.id),
+                "name": client.name,
+                "slug": client.slug,
+                "status": client.status,
+                "tool_scopes": list(client.tool_scopes),
+                "repo_scopes": list(client.repo_scopes),
+            },
+            "client_api_key": client_api_key,
+        }