synap-git 0.2.0__py3-none-any.whl

synap_git/mcp/server.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import functools
+import inspect
+import json
+import time
+import uuid
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from synap_git.indexer.engine import SynapRuntime
+
+
+class SynapMCPFacade:
+    """Model Context Protocol facade over the simplified Synap runtime."""
+
+    def __init__(self, runtime: SynapRuntime) -> None:
+        self.runtime = runtime
+
+    def get_status(self) -> dict[str, Any]:
+        status = self.runtime.status()
+        return status.__dict__
+
+    def search(self, query: str, max_tokens: int = 4000) -> dict[str, Any]:
+        result, ctx, debug = self.runtime.query_hybrid(query, max_tokens=max_tokens)
+        return {"result": result, "context": ctx, "trace": debug}
+
+    def create_checkpoint(
+        self, doing: str, changed_files: list[str], next_step: str, blockers: str
+    ) -> dict[str, Any]:
+        status = self.runtime.status()
+        checkpoint_id = str(uuid.uuid4())
+        branch = status.branch
+        commit = status.git_commit or "unknown"
+        self.runtime.store.put_checkpoint(
+            checkpoint_id, branch, commit, doing, json.dumps(changed_files), next_step, blockers
+        )
+        return {"status": "success", "checkpoint_id": checkpoint_id}
+
+    def restore_checkpoint(self, checkpoint_id: str) -> dict[str, Any]:
+        status = self.runtime.status()
+        cp = self.runtime.store.get_latest_checkpoint(status.branch)
+        if not cp:
+            raise ValueError("No checkpoint found for current branch.")
+        return dict(cp)
+
+    def log_decision(self, content: str, context_info: str) -> dict[str, Any]:
+        status = self.runtime.status()
+        decision_id = str(uuid.uuid4())
+        branch = status.branch
+        commit = status.git_commit or "unknown"
+        self.runtime.store.put_decision(decision_id, branch, commit, content, context_info)
+        return {"status": "success", "decision_id": decision_id}
+
+    def verify_system(self) -> dict[str, Any]:
+        res = self.runtime.doctor()
+        return res
+
+    def submit_lesson_analysis(self, lesson_id: str, why_failed: str) -> dict[str, Any]:
+        self.runtime.store.update_lesson(lesson_id, why_failed, "pending", actor="mcp_agent")
+        return {"status": "success", "message": "Lesson awaiting human approval"}
+
+    def get_approved_memory(self) -> dict[str, Any]:
+        lessons = self.runtime.store.get_lessons("approved")
+        return {"status": "success", "lessons": lessons}
+
+    def get_pending_memory(self) -> dict[str, Any]:
+        lessons = self.runtime.store.get_lessons("pending")
+        return {"status": "success", "lessons": lessons}
+
+
+class SynapMCPServer:
+    """Exposes Synap tools to AI agents via MCP Stdio."""
+
+    def __init__(self, runtime: SynapRuntime) -> None:
+        self.mcp = FastMCP("Synap Context Runtime")
+        self.facade = SynapMCPFacade(runtime)
+        self._register_tools()
+
+    def _register_tools(self) -> None:
+        from synap_git.diagnostics.logger import get_logger
+
+        logger = get_logger("mcp_server")
+
+        from collections.abc import Callable
+
+        def _wrap(f: Callable[..., dict[str, Any]]) -> Callable[..., str]:
+            @functools.wraps(f)
+            def wrapper(*args: Any, **kwargs: Any) -> str:
+                trace_id = str(uuid.uuid4())
+                try:
+                    status = self.facade.runtime.status()
+                    dirty = status.is_dirty
+                    warnings = []
+                    if dirty:
+                        warnings.append("Working tree is dirty. Index may be stale.")
+
+                    start = time.monotonic()
+                    data = f(*args, **kwargs)
+                    duration_ms = (time.monotonic() - start) * 1000
+                    logger.info(
+                        "mcp_tool_invoked",
+                        tool=f.__name__,
+                        latency_ms=duration_ms,
+                    )
+
+                    try:
+                        self.facade.runtime.trace_store.record_trace(
+                            trace_type="mcp",
+                            summary=f"MCP Tool Invoked: {f.__name__}",
+                            details={
+                                "tool": f.__name__,
+                                "arguments": kwargs,
+                                "duration_ms": duration_ms,
+                                "success": True,
+                                "trace_id": trace_id,
+                                "dirty_tree": dirty,
+                            },
+                        )
+                    except Exception:
+                        pass
+
+                    return json.dumps(
+                        {
+                            "ok": True,
+                            "data": data,
+                            "warnings": warnings,
+                            "trace_id": trace_id,
+                            "dirty_tree": dirty,
+                        }
+                    )
+                except Exception as e:
+                    msg = str(e)
+                    code = "INTERNAL_ERROR"
+                    suggestion = "Check daemon logs."
+
+                    if "stale" in msg.lower():
+                        code = "INDEX_STALE"
+                        suggestion = "Run `synap reindex` or wait for daemon."
+                    elif "no checkpoint" in msg.lower():
+                        code = "NOT_FOUND"
+                        suggestion = "Ensure checkpoints exist for this branch."
+
+                    logger.error("mcp_tool_error", tool=f.__name__, error=msg)
+
+                    try:
+                        self.facade.runtime.trace_store.record_trace(
+                            trace_type="mcp",
+                            summary=f"MCP Tool Failed: {f.__name__}",
+                            details={
+                                "tool": f.__name__,
+                                "arguments": kwargs,
+                                "error": msg,
+                                "success": False,
+                                "trace_id": trace_id,
+                            },
+                        )
+                    except Exception:
+                        pass
+
+                    return json.dumps(
+                        {
+                            "ok": False,
+                            "error": {"code": code, "message": msg, "suggestion": suggestion},
+                            "warnings": [],
+                            "trace_id": trace_id,
+                            "dirty_tree": False,
+                        }
+                    )
+
+            wrapper.__signature__ = inspect.signature(f)  # type: ignore
+            return wrapper
+
+        @self.mcp.tool()
+        @_wrap
+        def get_status() -> dict[str, Any]:
+            """Get current repository indexing status and active commit."""
+            return self.facade.get_status()
+
+        @self.mcp.tool()
+        @_wrap
+        def search(query: str, max_tokens: int = 4000) -> dict[str, Any]:
+            """Search the repository context for semantic and structural matches."""
+            return self.facade.search(query, max_tokens)
+
+        @self.mcp.tool()
+        @_wrap
+        def create_checkpoint(
+            doing: str, changed_files: list[str], next_step: str, blockers: str
+        ) -> dict[str, Any]:
+            """Save the current agent's thought process and state as a checkpoint."""
+            return self.facade.create_checkpoint(doing, changed_files, next_step, blockers)
+
+        @self.mcp.tool()
+        @_wrap
+        def restore_checkpoint() -> dict[str, Any]:
+            """Restore the latest checkpoint for the current branch to resume context."""
+            return self.facade.restore_checkpoint("latest")
+
+        @self.mcp.tool()
+        @_wrap
+        def log_decision(content: str, context_info: str) -> dict[str, Any]:
+            """Log an architectural or technical decision to the project's decision log."""
+            return self.facade.log_decision(content, context_info)
+
+        @self.mcp.tool()
+        @_wrap
+        def verify_system() -> dict[str, Any]:
+            """Verify database integrity and run internal diagnostics."""
+            return self.facade.verify_system()
+
+        @self.mcp.tool()
+        @_wrap
+        def submit_lesson_analysis(lesson_id: str, why_failed: str) -> dict[str, Any]:
+            """Submit an analysis for a pending lesson (e.g., after a revert). Lesson remains pending until human approval."""
+            return self.facade.submit_lesson_analysis(lesson_id, why_failed)
+
+        @self.mcp.tool()
+        @_wrap
+        def get_approved_memory() -> dict[str, Any]:
+            """Retrieve APPROVED memory lessons that MUST be strictly adhered to."""
+            return self.facade.get_approved_memory()
+
+        @self.mcp.tool()
+        @_wrap
+        def get_pending_memory() -> dict[str, Any]:
+            """Retrieve PENDING memory lessons currently awaiting human review."""
+            return self.facade.get_pending_memory()
+
+    async def run(self) -> None:
+        await self.mcp.run_stdio_async()

synap_git/parser/registry.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import tree_sitter_languages  # type: ignore
+from tree_sitter import Node, Parser
+
+from synap_git.utils.serialization import stable_hash
+
+PYTHON_SUFFIXES = {".py"}
+JAVASCRIPT_SUFFIXES = {".js", ".jsx"}
+TYPESCRIPT_SUFFIXES = {".ts", ".tsx"}
+GO_SUFFIXES = {".go"}
+RUST_SUFFIXES = {".rs"}
+JAVA_SUFFIXES = {".java"}
+CPP_SUFFIXES = {".cpp", ".cc", ".cxx", ".hpp", ".h"}
+RUBY_SUFFIXES = {".rb"}
+
+
+@dataclass(frozen=True)
+class CodeSymbol:
+    stable_id: str
+    kind: str
+    name: str
+    source_path: str
+    start_line: int
+    end_line: int
+    ast_hash: str
+    metadata: dict[str, Any] | None = None
+
+
+@dataclass(frozen=True)
+class CodeParseResult:
+    path: str
+    language: str
+    symbols: tuple[CodeSymbol, ...]
+    imports: tuple[str, ...] = ()
+    syntax_error: str | None = None
+
+
+class CodeParserRegistry:
+    """Deterministic AST parser using Tree-sitter for structural grounding."""
+
+    def __init__(self) -> None:
+        self._parsers: dict[str, Parser] = {}
+
+    def _get_parser(self, lang_name: str) -> Parser:
+        if lang_name not in self._parsers:
+            lang = tree_sitter_languages.get_language(lang_name)
+            parser = Parser()
+            parser.set_language(lang)
+            self._parsers[lang_name] = parser
+        return self._parsers[lang_name]
+
+    def parse(self, path: Path, *, relative_path: str) -> CodeParseResult:
+        suffix = path.suffix.lower()
+        text = path.read_text(encoding="utf-8", errors="replace")
+
+        if suffix in PYTHON_SUFFIXES:
+            return self._parse_tree_sitter(text, "python", relative_path)
+        if suffix in JAVASCRIPT_SUFFIXES:
+            return self._parse_tree_sitter(text, "javascript", relative_path)
+        if suffix in TYPESCRIPT_SUFFIXES:
+            return self._parse_tree_sitter(text, "tsx", relative_path)
+        if suffix in GO_SUFFIXES:
+            return self._parse_tree_sitter(text, "go", relative_path)
+        if suffix in RUST_SUFFIXES:
+            return self._parse_tree_sitter(text, "rust", relative_path)
+        if suffix in JAVA_SUFFIXES:
+            return self._parse_tree_sitter(text, "java", relative_path)
+        if suffix in CPP_SUFFIXES:
+            return self._parse_tree_sitter(text, "cpp", relative_path)
+        if suffix in RUBY_SUFFIXES:
+            return self._parse_tree_sitter(text, "ruby", relative_path)
+
+        return CodeParseResult(path=relative_path, language="unknown", symbols=())
+
+    def _parse_tree_sitter(self, text: str, lang_name: str, relative_path: str) -> CodeParseResult:
+        parser = self._get_parser(lang_name)
+        text_bytes = bytes(text, "utf8")
+        tree = parser.parse(text_bytes)
+
+        symbols: list[CodeSymbol] = []
+        imports: list[str] = []
+
+        def extract_text(node: Node | None) -> str | None:
+            if not node:
+                return None
+            return text_bytes[node.start_byte : node.end_byte].decode("utf-8", errors="replace")
+
+        # Simple recursive traversal to extract symbols
+        def traverse(node: Node) -> None:
+            kind = node.type
+            name = None
+
+            # Basic symbol extraction logic per language
+            if lang_name == "python":
+                if kind in ("class_definition", "function_definition"):
+                    name = extract_text(node.child_by_field_name("name"))
+                elif kind == "import_from_statement":
+                    mod_name = extract_text(node.child_by_field_name("module_name"))
+                    if mod_name:
+                        imports.append(mod_name)
+                elif kind == "import_statement":
+                    for child in node.children:
+                        if child.type == "dotted_name":
+                            imp_name = extract_text(child)
+                            if imp_name:
+                                imports.append(imp_name)
+
+            elif lang_name in ("javascript", "tsx"):
+                # Capturing classes, functions, methods, interfaces, and types
+                if kind in (
+                    "class_declaration",
+                    "function_declaration",
+                    "method_definition",
+                    "interface_declaration",
+                    "type_alias_declaration",
+                    "class",
+                ):
+                    name = extract_text(node.child_by_field_name("name"))
+                elif kind == "variable_declarator":
+                    # Catch const foo = () => ...
+                    value_node = node.child_by_field_name("value")
+                    if value_node and value_node.type in ("arrow_function", "function_expression"):
+                        name = extract_text(node.child_by_field_name("name"))
+                        if name:
+                            kind = "function_definition"
+
+                elif kind == "import_statement":
+                    src = extract_text(node.child_by_field_name("source"))
+                    if src:
+                        imports.append(src.strip("'\""))
+
+            elif lang_name == "go":
+                if kind in ("function_declaration", "method_declaration", "type_spec"):
+                    name = extract_text(node.child_by_field_name("name"))
+                elif kind == "import_spec":
+                    path_val = extract_text(node.child_by_field_name("path"))
+                    if path_val:
+                        imports.append(path_val.strip('"'))
+
+            elif lang_name == "rust":
+                if kind in ("function_item", "struct_item", "enum_item", "trait_item", "impl_item"):
+                    name = extract_text(node.child_by_field_name("name"))
+                    if not name and kind == "impl_item":
+                        t_name = extract_text(node.child_by_field_name("type"))
+                        if t_name:
+                            name = "impl " + t_name
+
+            elif lang_name == "java":
+                if kind in (
+                    "class_declaration",
+                    "method_declaration",
+                    "interface_declaration",
+                    "enum_declaration",
+                ):
+                    name = extract_text(node.child_by_field_name("name"))
+
+            elif lang_name == "cpp":
+                if kind in ("function_definition", "class_specifier", "struct_specifier"):
+                    name = extract_text(node.child_by_field_name("name"))
+                    if not name:
+                        # Fallback to declarator
+                        declarator = node.child_by_field_name("declarator")
+                        if declarator:
+                            name = extract_text(declarator.child_by_field_name("declarator"))
+
+            elif lang_name == "ruby":
+                if kind in ("class", "module", "method"):
+                    name = extract_text(node.child_by_field_name("name"))
+
+            if name:
+                # Compute hash of the node's subtree for change detection
+                ast_content = extract_text(node) or ""
+                ast_hash = stable_hash(ast_content)
+
+                # Ensure uniqueness by appending start/end lines if needed, but for now we rely on name/kind
+                # since stable_id uses path, name, kind. Wait, if multiple methods have same name (e.g. overloads)
+                # it will duplicate. Let's include start_line in stable_id to prevent IntegrityError!
+                sym_id = stable_hash(
+                    {"path": relative_path, "name": name, "kind": kind, "line": node.start_point[0]}
+                )
+
+                symbols.append(
+                    CodeSymbol(
+                        stable_id=sym_id,
+                        kind=kind,
+                        name=name,
+                        source_path=relative_path,
+                        start_line=node.start_point[0] + 1,
+                        end_line=node.end_point[0] + 1,
+                        ast_hash=ast_hash,
+                    )
+                )
+
+            for child in node.children:
+                traverse(child)
+
+        traverse(tree.root_node)
+
+        return CodeParseResult(
+            path=relative_path,
+            language=lang_name,
+            symbols=tuple(symbols),
+            imports=tuple(sorted(set(imports))),
+        )

synap_git/provider/anthropic.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import json
+import urllib.request
+from typing import Any
+
+from synap_git.provider.base import LLMProvider, LLMResponse
+
+
+class AnthropicProvider(LLMProvider):
+    """Anthropic API provider implementation."""
+
+    def __init__(self, api_key: str, default_model: str = "claude-3-5-sonnet-latest") -> None:
+        self.api_key = api_key
+        self.default_model = default_model
+
+    def generate(
+        self,
+        system_prompt: str,
+        user_prompt: str,
+        *,
+        model: str | None = None,
+        max_tokens: int | None = None,
+        temperature: float = 0.2,
+    ) -> LLMResponse:
+        model_name = model or self.default_model
+        url = "https://api.anthropic.com/v1/messages"
+        headers = {
+            "Content-Type": "application/json",
+            "x-api-key": self.api_key,
+            "anthropic-version": "2023-06-01",
+        }
+
+        payload: dict[str, Any] = {
+            "model": model_name,
+            "system": system_prompt,
+            "messages": [
+                {"role": "user", "content": user_prompt},
+            ],
+            "temperature": temperature,
+            "max_tokens": max_tokens or 4096,
+        }
+
+        req = urllib.request.Request(
+            url, data=json.dumps(payload).encode("utf-8"), headers=headers, method="POST"
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=45.0) as resp:  # nosec B310
+                data = json.loads(resp.read().decode("utf-8"))
+
+            content = data["content"][0]["text"]
+            usage = data.get("usage", {})
+            prompt_tokens = usage.get("input_tokens", 0)
+            completion_tokens = usage.get("output_tokens", 0)
+            cached_tokens = usage.get("cache_creation_input_tokens", 0) + usage.get(
+                "cache_read_input_tokens", 0
+            )
+
+            return LLMResponse(
+                content=content,
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                cached_tokens=cached_tokens,
+            )
+        except Exception as exc:
+            raise RuntimeError(f"Anthropic generate failed: {exc}") from exc
+
+    def embed(
+        self,
+        text: str,
+        *,
+        model: str | None = None,
+    ) -> list[float]:
+        # Anthropic does not have a public embedding endpoint as of mid 2024.
+        # Typically developers use Voyage or OpenAI for embeddings when using Anthropic.
+        # We will throw a clear error.
+        raise NotImplementedError(
+            "Anthropic does not provide a native embeddings API. Please configure SYNAP_EMBED_PROVIDER=ollama or openai."
+        )
+
+    def count_tokens(self, text: str) -> int:
+        import tiktoken
+
+        # Anthropic approximates closely with cl100k_base
+        encoding = tiktoken.get_encoding("cl100k_base")
+        return len(encoding.encode(text, disallowed_special=()))

synap_git/provider/base.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class LLMResponse:
+    content: str
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    cached_tokens: int = 0
+
+
+class LLMProvider(ABC):
+    """Abstract interface for LLM provider clients."""
+
+    @abstractmethod
+    def generate(
+        self,
+        system_prompt: str,
+        user_prompt: str,
+        *,
+        model: str | None = None,
+        max_tokens: int | None = None,
+        temperature: float = 0.2,
+    ) -> LLMResponse:
+        """Generate a response for the given prompts."""
+        pass
+
+    @abstractmethod
+    def embed(
+        self,
+        text: str,
+        *,
+        model: str | None = None,
+    ) -> list[float]:
+        """Generate a vector embedding for the given text."""
+        pass
+
+    @abstractmethod
+    def count_tokens(self, text: str) -> int:
+        """Count the number of tokens in the given text."""
+        pass

synap_git/provider/factory.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from synap_git.config import RuntimeProfile, SynapSettings
+from synap_git.provider.anthropic import AnthropicProvider
+from synap_git.provider.base import LLMProvider
+from synap_git.provider.gemini import GeminiProvider
+from synap_git.provider.mock import MockLLMProvider
+from synap_git.provider.ollama import OllamaProvider
+from synap_git.provider.openai import OpenAIProvider
+
+
+def get_llm_provider(settings: SynapSettings) -> LLMProvider | None:
+    """Create an LLM provider based on runtime settings.
+
+    Strictly enforces provider configuration. Returns None for explicit Mode A
+    (structural only). Mock provider is ONLY allowed during TEST profile.
+    """
+    if settings.profile == RuntimeProfile.TEST:
+        return MockLLMProvider()
+
+    if not settings.llm_provider:
+        return None
+
+    provider_name = str(settings.llm_provider).lower().strip()
+
+    if provider_name == "openai":
+        if not settings.openai_api_key:
+            raise ValueError(
+                "OpenAI API key missing. Set SYNAP_OPENAI_API_KEY or "
+                "configure it in ~/.config/synap/config.toml"
+            )
+        return OpenAIProvider(
+            api_key=settings.openai_api_key,
+            default_model=settings.llm_model or "",
+        )
+
+    if provider_name == "gemini":
+        if not settings.gemini_api_key:
+            raise ValueError(
+                "Gemini API key missing. Set SYNAP_GEMINI_API_KEY or "
+                "configure it in ~/.config/synap/config.toml"
+            )
+        return GeminiProvider(
+            api_key=settings.gemini_api_key,
+            default_model=settings.llm_model or "",
+        )
+
+    if provider_name == "anthropic":
+        if not settings.anthropic_api_key:
+            raise ValueError(
+                "Anthropic API key missing. Set SYNAP_ANTHROPIC_API_KEY or "
+                "configure it in ~/.config/synap/config.toml"
+            )
+        return AnthropicProvider(
+            api_key=settings.anthropic_api_key,
+            default_model=settings.llm_model or "",
+        )
+
+    if provider_name == "ollama":
+        return OllamaProvider(
+            base_url=settings.ollama_url,
+            default_model=settings.llm_model or "",
+        )
+
+    raise ValueError(f"Unsupported or unconfigured LLM provider: {provider_name}")
+
+
+def get_embed_provider(settings: SynapSettings) -> LLMProvider | None:
+    """Create an embedding provider based on runtime settings."""
+    if settings.profile == RuntimeProfile.TEST:
+        return MockLLMProvider()
+
+    if not settings.llm_provider:
+        return None
+
+    provider_name = str(settings.llm_provider).lower().strip()
+    model = settings.llm_model or ""
+
+    if provider_name == "openai":
+        if not settings.openai_api_key:
+            raise ValueError("OpenAI API key missing for embeddings.")
+        return OpenAIProvider(
+            api_key=settings.openai_api_key,
+            default_model=model,
+        )
+
+    if provider_name == "gemini":
+        if not settings.gemini_api_key:
+            raise ValueError("Gemini API key missing for embeddings.")
+        return GeminiProvider(
+            api_key=settings.gemini_api_key,
+            default_model=model,
+        )
+
+    if provider_name == "ollama":
+        return OllamaProvider(
+            base_url=settings.ollama_url,
+            default_model=model,
+        )
+
+    raise ValueError(f"Unsupported or unconfigured embedding provider: {provider_name}")