contextsynapse 1.0.0__py3-none-any.whl

contextsynapse/vector/vector_db_manager.py

@@ -0,0 +1,197 @@
+"""
+Vector Database Manager with Configuration Support
+Allows easy switching between different vector DB backends.
+"""
+
+import logging
+from typing import Optional, Dict, Any, List
+from enum import Enum
+from pathlib import Path
+import os
+
+logger = logging.getLogger(__name__)
+
+class VectorDBBackend(Enum):
+    """Supported vector database backends."""
+    CUSTOM = "custom"  # NumPy-based (default, works everywhere)
+    FAISS = "faiss"    # FAISS (fast, but Windows issues)
+    CHROMA = "chroma"  # ChromaDB (cross-platform)
+    QDRANT = "qdrant"  # Qdrant (cross-platform)
+    PINECONE = "pinecone"  # Pinecone (cloud)
+    WEAVIATE = "weaviate"  # Weaviate (cross-platform)
+
+class VectorDBManager:
+    """
+    Manages vector database backends with easy switching via configuration.
+    
+    Configuration sources (in order of priority):
+    1. Environment variable: AICONTEXTDB_VECTOR_DB_BACKEND
+    2. Config file: .env or config.yaml
+    3. Default: CUSTOM (NumPy-based)
+    """
+    
+    def __init__(self, backend: Optional[str] = None, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize vector DB manager.
+        
+        Args:
+            backend: Backend name ("custom", "faiss", "chroma", etc.)
+            config: Optional configuration dict
+        """
+        self.config = config or {}
+        self.backend_name = self._get_backend_name(backend)
+        self.backend = self._create_backend()
+        
+        logger.info(f"Vector DB Manager initialized with backend: {self.backend_name}")
+    
+    def _get_backend_name(self, backend: Optional[str] = None) -> str:
+        """Get backend name from various sources."""
+        # Priority 1: Explicit parameter
+        if backend:
+            return backend.lower()
+        
+        # Priority 2: Environment variable
+        env_backend = os.getenv("CONTEXTSYNAPSE_VECTOR_DB_BACKEND") or os.getenv("AICONTEXTDB_VECTOR_DB_BACKEND", "").lower().strip()
+        if env_backend:
+            return env_backend
+        
+        # Priority 3: Config file (check both vector_db.backend and vector_db_backend for compatibility)
+        vector_db_config = self.config.get("vector_db", {})
+        if isinstance(vector_db_config, dict):
+            config_backend = vector_db_config.get("backend", "").lower().strip()
+        else:
+            config_backend = ""
+        
+        # Also check legacy format
+        if not config_backend:
+            config_backend = self.config.get("vector_db_backend", "").lower().strip()
+        
+        if config_backend:
+            return config_backend
+        
+        # Priority 4: Qdrant if QDRANT_URL is set (running server)
+        if os.getenv("QDRANT_URL"):
+            return "qdrant"
+
+        # Priority 5: Fallback to CUSTOM (NumPy-based, works everywhere)
+        return "custom"
+    
+    def _create_backend(self):
+        """Create the appropriate vector store backend."""
+        try:
+            if self.backend_name == "custom":
+                from .custom_vector_store import CustomVectorStore
+                return CustomVectorStore
+            elif self.backend_name == "faiss":
+                from .faiss_vector_store import FAISSVectorStore
+                return FAISSVectorStore
+            elif self.backend_name == "chroma":
+                from .chroma_vector_store import ChromaVectorStore
+                return ChromaVectorStore
+            elif self.backend_name == "qdrant":
+                from .qdrant_vector_store import QdrantVectorStore
+                return QdrantVectorStore
+            else:
+                logger.warning(f"Unknown backend '{self.backend_name}', falling back to 'custom'")
+                from .custom_vector_store import CustomVectorStore
+                return CustomVectorStore
+        except ImportError as e:
+            logger.warning(f"Backend '{self.backend_name}' not available ({e}), falling back to 'custom'")
+            from .custom_vector_store import CustomVectorStore
+            return CustomVectorStore
+    
+    def create_store(self, dimension: int, metric: str = "cosine", **kwargs) -> Any:
+        """
+        Create a vector store instance.
+        
+        Args:
+            dimension: Vector dimension
+            metric: Similarity metric ("cosine", "euclidean", "dot")
+            **kwargs: Additional backend-specific parameters
+        
+        Returns:
+            Vector store instance
+        """
+        try:
+            if self.backend_name == "custom":
+                return self.backend(dimension=dimension, metric=metric)
+            elif self.backend_name == "faiss":
+                index_type = kwargs.get("index_type", "flat")
+                return self.backend(dimension=dimension, metric=metric, index_type=index_type)
+            elif self.backend_name == "chroma":
+                collection_name = kwargs.get("collection_name", "default")
+                persist_directory = kwargs.get("persist_directory", None)
+                return self.backend(
+                    dimension=dimension,
+                    metric=metric,
+                    collection_name=collection_name,
+                    persist_directory=persist_directory
+                )
+            elif self.backend_name == "qdrant":
+                collection_name = kwargs.get("collection_name", "default")
+                url = kwargs.get("url") or os.environ.get("QDRANT_URL")
+                path = kwargs.get("path") or (f"contextcore_data/qdrant" if not url else None)
+                # Try remote first, fall back to embedded if remote is unreachable
+                if url:
+                    try:
+                        store = self.backend(
+                            dimension=dimension, metric=metric,
+                            collection_name=collection_name, url=url,
+                        )
+                        # Quick health check
+                        store.client.get_collections()
+                        return store
+                    except Exception as e:
+                        logger.warning("Qdrant remote (%s) unreachable: %s — falling back to embedded mode", url, e)
+                        path = f"contextcore_data/qdrant"
+                return self.backend(
+                    dimension=dimension, metric=metric,
+                    collection_name=collection_name, path=path,
+                )
+            else:
+                # Default: custom
+                return self.backend(dimension=dimension, metric=metric)
+        except Exception as e:
+            logger.error(f"Failed to create vector store: {e}")
+            # Fallback to custom
+            from .custom_vector_store import CustomVectorStore
+            return CustomVectorStore(dimension=dimension, metric=metric)
+    
+    def get_backend_info(self) -> Dict[str, Any]:
+        """Get information about the current backend."""
+        return {
+            "backend": self.backend_name,
+            "available": self.backend is not None,
+            "description": self._get_backend_description()
+        }
+    
+    def _get_backend_description(self) -> str:
+        """Get description of current backend."""
+        descriptions = {
+            "custom": "NumPy-based custom vector store (cross-platform, no dependencies)",
+            "faiss": "FAISS vector store (fast, but may have Windows issues)",
+            "chroma": "ChromaDB vector store (cross-platform, feature-rich)",
+            "qdrant": "Qdrant vector store (cross-platform, production-ready)",
+            "pinecone": "Pinecone cloud vector store (managed service)",
+            "weaviate": "Weaviate vector store (graph + vector database)"
+        }
+        return descriptions.get(self.backend_name, "Unknown backend")
+
+# Global manager instance
+_global_manager: Optional[VectorDBManager] = None
+
+def get_vector_db_manager(backend: Optional[str] = None, config: Optional[Dict[str, Any]] = None) -> VectorDBManager:
+    """Get or create global vector DB manager."""
+    global _global_manager
+    if _global_manager is None:
+        _global_manager = VectorDBManager(backend=backend, config=config)
+    return _global_manager
+
+def set_vector_db_backend(backend: str):
+    """Set the vector DB backend globally."""
+    global _global_manager
+    _global_manager = VectorDBManager(backend=backend)
+    logger.info(f"Vector DB backend set to: {backend}")
+
+
+

contextsynapse/workspace/__init__.py

@@ -0,0 +1,27 @@
+"""
+Workspace — where agents produce artifacts.
+
+A workspace gives agents a sandboxed directory to write code, create files,
+run commands, and push to Git. Each session/project gets its own workspace.
+
+Backends:
+    - LocalWorkspace: filesystem under generated/<project>/
+    - GitWorkspace: local git repo with branch/commit/push
+    - GitHubWorkspace: remote GitHub repo via API
+
+Usage:
+    ws = GitWorkspace.from_config({
+        "type": "git",
+        "repo_url": "https://github.com/user/my-app.git",
+        "branch": "feat/abc-website",
+    })
+    ws.write_file("src/App.jsx", content)
+    ws.commit("Add homepage component")
+    ws.push()
+"""
+
+from .base import Workspace
+from .local import LocalWorkspace
+from .git import GitWorkspace
+
+__all__ = ["Workspace", "LocalWorkspace", "GitWorkspace"]

contextsynapse/workspace/base.py

@@ -0,0 +1,94 @@
+"""
+Workspace base class — unified interface for agent file operations.
+"""
+
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class Workspace(ABC):
+    """Abstract workspace that agents write artifacts to."""
+
+    @abstractmethod
+    def write_file(self, filepath: str, content: str) -> str:
+        """Write a file. Returns confirmation message."""
+
+    @abstractmethod
+    def read_file(self, filepath: str) -> str:
+        """Read a file. Returns content or error."""
+
+    @abstractmethod
+    def list_files(self, path: str = ".") -> List[str]:
+        """List files in the workspace."""
+
+    @abstractmethod
+    def delete_file(self, filepath: str) -> str:
+        """Delete a file. Returns confirmation."""
+
+    def commit(self, message: str, files: Optional[List[str]] = None) -> str:
+        """Commit changes (no-op for non-git workspaces)."""
+        return "Commits not supported in this workspace type."
+
+    def push(self, branch: Optional[str] = None) -> str:
+        """Push to remote (no-op for non-git workspaces)."""
+        return "Push not supported in this workspace type."
+
+    def create_branch(self, branch: str) -> str:
+        """Create and switch to a branch."""
+        return "Branches not supported in this workspace type."
+
+    def run_command(self, command: str, timeout: int = 60) -> str:
+        """Run a shell command in the workspace directory."""
+        return "Command execution not supported in this workspace type."
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get workspace status (file count, git status, etc.)."""
+        return {"type": self.__class__.__name__, "files": len(self.list_files())}
+
+    @staticmethod
+    def from_config(config: Dict[str, Any]) -> "Workspace":
+        """Factory: create a workspace from a config dict.
+
+        Config keys:
+            type: "local" | "git" | "github"
+            path: local directory path (for local/git)
+            repo_url: git remote URL (for git)
+            branch: default branch name
+            github_token: GitHub PAT (for github type)
+            github_repo: "owner/repo" (for github type)
+        """
+        ws_type = config.get("type", "local")
+
+        if ws_type == "local":
+            from .local import LocalWorkspace
+            return LocalWorkspace(base_path=config.get("path", "generated"))
+
+        if ws_type == "git":
+            from .git import GitWorkspace
+            repo_url = config.get("repo_url", "")
+            token = config.get("token", "")
+            # Inject token into URL for private repo auth (PAT-based)
+            if token and repo_url and "github.com" in repo_url and "@" not in repo_url:
+                repo_url = repo_url.replace("https://", f"https://{token}@")
+            return GitWorkspace(
+                base_path=config.get("path", "generated"),
+                repo_url=repo_url,
+                branch=config.get("branch", "main"),
+                auto_clone=config.get("auto_clone", True),
+            )
+
+        if ws_type == "github":
+            from .github import GitHubWorkspace
+            return GitHubWorkspace(
+                token=config["github_token"],
+                repo=config["github_repo"],
+                branch=config.get("branch", "main"),
+                local_path=config.get("path"),
+            )
+
+        raise ValueError(f"Unknown workspace type: {ws_type}")

contextsynapse/workspace/git.py

@@ -0,0 +1,228 @@
+"""
+Git Workspace — local git repo with branch/commit/push.
+
+Agents work like real developers:
+1. Clone or init a repo
+2. Create a feature branch
+3. Write files
+4. Commit changes
+5. Push to remote
+6. (Optionally) create a PR via GitHub API
+
+Usage:
+    ws = GitWorkspace(
+        base_path="workspaces/abc-website",
+        repo_url="https://github.com/user/abc-website.git",
+        branch="feat/homepage",
+    )
+    ws.write_file("src/App.jsx", code)
+    ws.commit("Add homepage component")
+    ws.push()
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+from typing import Any, Dict, List, Optional
+
+from .local import LocalWorkspace
+
+logger = logging.getLogger(__name__)
+
+
+class GitWorkspace(LocalWorkspace):
+    """Workspace backed by a local git repo with remote push capability."""
+
+    _git_lock = None  # Thread lock for git operations
+
+    def __init__(
+        self,
+        base_path: str = "generated",
+        repo_url: Optional[str] = None,
+        branch: str = "main",
+        auto_clone: bool = True,
+    ):
+        import threading
+        if GitWorkspace._git_lock is None:
+            GitWorkspace._git_lock = threading.Lock()
+        self.repo_url = repo_url
+        self.branch = branch
+        self._current_branch = branch
+
+        # If repo_url provided and auto_clone, clone into base_path
+        if repo_url and auto_clone and not os.path.exists(os.path.join(base_path, ".git")):
+            parent = os.path.dirname(os.path.abspath(base_path))
+            os.makedirs(parent, exist_ok=True)
+            self._run_git(["clone", repo_url, os.path.abspath(base_path)], cwd=parent)
+
+        super().__init__(base_path)
+
+        # Init git if no repo exists
+        if not os.path.exists(os.path.join(self.base_path, ".git")):
+            self._run_git(["init"])
+            self._run_git(["checkout", "-b", branch])
+
+        # Always ensure remote URL is up-to-date (token may have changed)
+        if repo_url and os.path.exists(os.path.join(self.base_path, ".git")):
+            remotes = self._run_git(["remote"])
+            if "origin" in remotes:
+                self._run_git(["remote", "set-url", "origin", repo_url])
+            else:
+                self._run_git(["remote", "add", "origin", repo_url])
+
+        # Configure git user for commits (required in clean environments)
+        self._run_git(["config", "user.email", "agent@contextsynapse.com"])
+        self._run_git(["config", "user.name", "AIContextDB Agent"])
+
+    def _run_git(self, args: List[str], cwd: Optional[str] = None) -> str:
+        """Run a git command with thread-safe locking."""
+        cmd = ["git"] + args
+        # Acquire lock for mutating operations to prevent index.lock conflicts
+        mutating = args[0] in ("add", "commit", "push", "pull", "checkout", "merge", "reset", "stash")
+        if mutating and GitWorkspace._git_lock:
+            GitWorkspace._git_lock.acquire()
+        try:
+            # Clean up stale lock file before mutating operations
+            if mutating:
+                lock_file = os.path.join(cwd or self.base_path, ".git", "index.lock")
+                if os.path.exists(lock_file):
+                    try:
+                        os.remove(lock_file)
+                        logger.debug("Removed stale .git/index.lock")
+                    except Exception:
+                        pass
+
+            result = subprocess.run(
+                cmd,
+                cwd=cwd or self.base_path,
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            if result.returncode != 0:
+                error = result.stderr.strip() or result.stdout.strip()
+                logger.warning("git %s failed: %s", " ".join(args), error)
+                return f"Error: {error}"
+            return result.stdout.strip()
+        except subprocess.TimeoutExpired:
+            return "Error: git command timed out"
+        except FileNotFoundError:
+            return "Error: git not found. Install git to use GitWorkspace."
+        finally:
+            if mutating and GitWorkspace._git_lock and GitWorkspace._git_lock.locked():
+                GitWorkspace._git_lock.release()
+
+    def create_branch(self, branch: str) -> str:
+        """Create and switch to a new branch."""
+        result = self._run_git(["checkout", "-b", branch])
+        if not result.startswith("Error"):
+            self._current_branch = branch
+            return f"Created and switched to branch: {branch}"
+        # Branch might already exist
+        result = self._run_git(["checkout", branch])
+        if not result.startswith("Error"):
+            self._current_branch = branch
+            return f"Switched to existing branch: {branch}"
+        return result
+
+    def commit(self, message: str, files: Optional[List[str]] = None) -> str:
+        """Stage and commit changes."""
+        if files:
+            for f in files:
+                self._run_git(["add", f])
+        else:
+            self._run_git(["add", "-A"])
+
+        # Check if there's anything to commit
+        status = self._run_git(["status", "--porcelain"])
+        if not status or status.startswith("Error"):
+            return "Nothing to commit."
+
+        result = self._run_git(["commit", "-m", message])
+        if result.startswith("Error"):
+            return result
+
+        # Get short hash
+        sha = self._run_git(["rev-parse", "--short", "HEAD"])
+        return f"Committed ({sha}): {message}"
+
+    def push(self, branch: Optional[str] = None) -> str:
+        """Push to remote."""
+        if not self.repo_url:
+            return "No remote configured. Set repo_url to enable push."
+
+        branch = branch or self._current_branch
+        logger.info("Pushing branch %s to %s", branch, self.repo_url.split("@")[-1] if "@" in self.repo_url else self.repo_url)
+
+        # Check if there are commits to push
+        log = self._run_git(["log", "--oneline", "-1"])
+        if not log or log.startswith("Error"):
+            return "Nothing to push — no commits yet."
+
+        result = self._run_git(["push", "-u", "origin", branch])
+        if result.startswith("Error"):
+            # Try with --set-upstream for new branches
+            result = self._run_git(["push", "--set-upstream", "origin", branch])
+        if result.startswith("Error"):
+            logger.error("Git push failed: %s", result)
+            return result
+        logger.info("Push succeeded: %s", branch)
+        return f"Pushed to origin/{branch}"
+
+    def pull(self, branch: Optional[str] = None) -> str:
+        """Pull latest from remote."""
+        branch = branch or self._current_branch
+        return self._run_git(["pull", "origin", branch])
+
+    def git_status(self) -> str:
+        """Get git status."""
+        return self._run_git(["status", "--short"])
+
+    def git_log(self, n: int = 10) -> str:
+        """Get recent git log."""
+        return self._run_git(["log", f"--oneline", f"-{n}"])
+
+    def git_diff(self, staged: bool = False) -> str:
+        """Get diff of changes."""
+        args = ["diff"]
+        if staged:
+            args.append("--staged")
+        return self._run_git(args)
+
+    def run_command(self, command: str, timeout: int = 120) -> str:
+        """Run a shell command in the workspace directory."""
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                cwd=self.base_path,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+            output = result.stdout
+            if result.stderr:
+                output += "\n" + result.stderr
+            if result.returncode != 0:
+                output = f"Exit code {result.returncode}\n{output}"
+            return output.strip()[:5000]
+        except subprocess.TimeoutExpired:
+            return f"Error: command timed out after {timeout}s"
+
+    def get_status(self) -> Dict[str, Any]:
+        status = super().get_status()
+        status["type"] = "git"
+        status["branch"] = self._current_branch
+        # Strip token from URL for display
+        import re
+        safe_url = re.sub(r'://[^@]+@', '://', self.repo_url or "")
+        status["repo_url"] = safe_url
+        status["git_status"] = self.git_status()
+        return status
+
+    def write_file(self, filepath: str, content: str) -> str:
+        """Write file and report git-relevant info."""
+        result = super().write_file(filepath, content)
+        return result

contextsynapse/workspace/github.py

@@ -0,0 +1,78 @@
+"""
+GitHub Workspace — remote workspace via GitHub API.
+
+For agents that don't have local filesystem access. Files are pushed
+directly to GitHub via the Contents API.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from .base import Workspace
+
+logger = logging.getLogger(__name__)
+
+
+class GitHubWorkspace(Workspace):
+    """Workspace backed by GitHub API — no local filesystem needed."""
+
+    def __init__(
+        self,
+        token: str,
+        repo: str,
+        branch: str = "main",
+        local_path: Optional[str] = None,
+    ):
+        from ..connectors.github import GitHubConnector
+
+        self._gh = GitHubConnector(token=token, repo=repo, branch=branch)
+        self.repo = repo
+        self.branch = branch
+        self._local_path = local_path
+
+    def write_file(self, filepath: str, content: str) -> str:
+        result = self._gh.push_file(filepath, content, message=f"Update {filepath}", branch=self.branch)
+        if "error" in str(result).lower():
+            return f"Error writing {filepath}: {result}"
+        sha = result.get("commit", {}).get("sha", "")[:7]
+        return f"Pushed {filepath} to {self.repo}@{self.branch} ({sha})"
+
+    def read_file(self, filepath: str) -> str:
+        content = self._gh.get_file(filepath, branch=self.branch)
+        if content is None:
+            return f"File not found: {filepath}"
+        return content
+
+    def list_files(self, path: str = ".") -> List[str]:
+        tree = self._gh.get_tree(branch=self.branch)
+        return [f["path"] for f in tree if f.get("type") == "blob"]
+
+    def delete_file(self, filepath: str) -> str:
+        result = self._gh.delete_file(filepath, message=f"Delete {filepath}", branch=self.branch)
+        if "error" in str(result).lower():
+            return f"Error: {result}"
+        return f"Deleted {filepath} from {self.repo}@{self.branch}"
+
+    def create_branch(self, branch: str) -> str:
+        result = self._gh.create_branch(branch, from_branch=self.branch)
+        if "error" in str(result).lower():
+            return f"Error: {result}"
+        self.branch = branch
+        return f"Created branch {branch} on {self.repo}"
+
+    def commit(self, message: str, files: Optional[List[str]] = None) -> str:
+        # GitHub API commits happen per-file in write_file
+        return f"Changes committed via GitHub API (commits happen per write_file call)"
+
+    def push(self, branch: Optional[str] = None) -> str:
+        # GitHub API pushes happen per-file
+        return f"Changes are already pushed via GitHub API"
+
+    def get_status(self) -> Dict[str, Any]:
+        return {
+            "type": "github",
+            "repo": self.repo,
+            "branch": self.branch,
+        }