synap-git 0.2.0__py3-none-any.whl

synap_git/config.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import os
+from enum import StrEnum
+from pathlib import Path
+from typing import Self
+
+import keyring
+from pydantic import Field, field_validator, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class RuntimeProfile(StrEnum):
+    DEV = "dev"
+    TEST = "test"
+    PROD = "prod"
+
+
+class RuntimeMode(StrEnum):
+    IDLE = "idle"
+    ACTIVE = "active"
+
+
+class LoggingMode(StrEnum):
+    HUMAN = "human"
+    JSON = "json"
+
+
+def _get_config_file_path() -> Path:
+    """Get global Synap config file path (XDG-compliant)."""
+    if env_path := os.environ.get("SYNAP_CONFIG"):
+        return Path(env_path).expanduser()
+    return Path.home() / ".config" / "synap" / "config.toml"
+
+
+class SynapSettings(BaseSettings):
+    """Production-grade configuration with secure secret management."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="SYNAP_",
+        env_file=str(_get_config_file_path()),
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    profile: RuntimeProfile = RuntimeProfile.DEV
+    mode: RuntimeMode = RuntimeMode.ACTIVE
+
+    repository_path: Path = Field(default=Path(), description="Repository root.")
+    state_path: Path = Field(default=Path(".synap"), description="Local runtime state.")
+    sqlite_path: Path | None = None
+    object_path: Path | None = None
+    log_path: Path | None = None
+
+    logging_mode: LoggingMode = LoggingMode.HUMAN
+    log_level: str = "INFO"
+
+    max_file_bytes: int = Field(default=1_000_000, ge=1_024)
+
+    llm_provider: str | None = Field(
+        default=None,
+        description="LLM provider (openai, gemini, ollama). Leave empty for Mode A (structural only).",
+    )
+    llm_model: str | None = Field(default=None, description="LLM model.")
+    ollama_url: str = "http://127.0.0.1:11434"
+
+    mcp_host: str = "127.0.0.1"
+    mcp_port: int = 9876
+
+    daemon_poll_interval_seconds: float = 2.0
+
+    def _get_fallback_credential(self, key: str) -> str | None:
+        try:
+            cred_file = Path.home() / ".synap" / "credentials"
+            if cred_file.exists():
+                for line in cred_file.read_text().splitlines():
+                    if line.strip().startswith(f"{key}="):
+                        return line.split("=", 1)[1].strip().strip("\"'")
+        except Exception:
+            pass
+        return None
+
+    @property
+    def openai_api_key(self) -> str | None:
+        return (
+            keyring.get_password("synap", "openai_api_key")
+            or os.environ.get("SYNAP_OPENAI_API_KEY")
+            or self._get_fallback_credential("SYNAP_OPENAI_API_KEY")
+        )
+
+    @property
+    def gemini_api_key(self) -> str | None:
+        return (
+            keyring.get_password("synap", "gemini_api_key")
+            or os.environ.get("SYNAP_GEMINI_API_KEY")
+            or self._get_fallback_credential("SYNAP_GEMINI_API_KEY")
+        )
+
+    @property
+    def anthropic_api_key(self) -> str | None:
+        return (
+            keyring.get_password("synap", "anthropic_api_key")
+            or os.environ.get("SYNAP_ANTHROPIC_API_KEY")
+            or self._get_fallback_credential("SYNAP_ANTHROPIC_API_KEY")
+        )
+
+    @field_validator("repository_path", "state_path", mode="before")
+    @classmethod
+    def _expand_path(cls, value: str | Path) -> Path:
+        return Path(value).expanduser()
+
+    @model_validator(mode="after")
+    def _derive_paths(self) -> Self:
+        repository_path = self.repository_path.resolve()
+        state_path = self.state_path
+        if not state_path.is_absolute():
+            state_path = repository_path / state_path
+        self.repository_path = repository_path
+        self.state_path = state_path.resolve()
+        self.sqlite_path = self._resolve_optional_path(self.sqlite_path, "synap.db")
+        self.object_path = self._resolve_optional_path(self.object_path, "objects")
+        self.log_path = self._resolve_optional_path(self.log_path, "logs")
+
+        if self.profile is RuntimeProfile.TEST:
+            self.logging_mode = LoggingMode.JSON
+            self.log_level = "DEBUG"
+        return self
+
+    def _resolve_optional_path(self, value: Path | None, default_name: str) -> Path:
+        path = value or self.state_path / default_name
+        if not path.is_absolute():
+            path = self.repository_path / path
+        return path.resolve()
+
+    def ensure_directories(self) -> None:
+        self.state_path.mkdir(parents=True, exist_ok=True)
+        if self.object_path:
+            self.object_path.mkdir(parents=True, exist_ok=True)
+        if self.log_path:
+            self.log_path.mkdir(parents=True, exist_ok=True)
+
+    def validate_configuration(self) -> list[str]:
+        errors = []
+
+        if self.llm_provider == "openai" and not self.openai_api_key:
+            errors.append("Missing OpenAI API key in keyring or SYNAP_OPENAI_API_KEY")
+        if self.llm_provider == "gemini" and not self.gemini_api_key:
+            errors.append("Missing Gemini API key in keyring or SYNAP_GEMINI_API_KEY")
+        if self.llm_provider == "anthropic" and not self.anthropic_api_key:
+            errors.append("Missing Anthropic API key in keyring or SYNAP_ANTHROPIC_API_KEY")
+
+        return errors
+
+    def test_connectivity(self) -> list[str]:
+        errors = []
+        from synap_git.provider.factory import get_llm_provider
+
+        try:
+            get_llm_provider(self)
+            if self.llm_provider == "ollama":
+                import httpx
+
+                resp = httpx.get(f"{self.ollama_url}/api/tags", timeout=2.0)
+                if resp.status_code != 200:
+                    errors.append(f"Ollama offline: {resp.status_code}")
+        except Exception as e:
+            errors.append(f"Provider init failed: {e}")
+        return errors

synap_git/diagnostics/logger.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import sys
+import time
+from collections.abc import Iterator
+from dataclasses import dataclass
+from typing import cast
+from uuid import uuid4
+
+import structlog
+
+from synap_git.config import LoggingMode, SynapSettings
+
+
+@dataclass(frozen=True)
+class TraceResult:
+    correlation_id: str
+    latency_ms: float
+
+
+def configure_logging(settings: SynapSettings) -> None:
+    timestamper = structlog.processors.TimeStamper(fmt="iso", utc=True)
+    shared_processors: list[structlog.typing.Processor] = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_log_level,
+        timestamper,
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+    ]
+    renderer: structlog.typing.Processor
+    if settings.logging_mode is LoggingMode.JSON:
+        renderer = structlog.processors.JSONRenderer()
+    else:
+        renderer = structlog.dev.ConsoleRenderer(colors=False)
+
+    logging.basicConfig(
+        format="%(message)s",
+        stream=sys.stderr,
+        level=getattr(logging, settings.log_level.upper(), logging.INFO),
+    )
+    structlog.configure(
+        processors=[*shared_processors, renderer],
+        wrapper_class=structlog.stdlib.BoundLogger,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+
+def get_logger(subsystem: str) -> structlog.stdlib.BoundLogger:
+    logger = structlog.get_logger("synap").bind(subsystem=subsystem)
+    return cast(structlog.stdlib.BoundLogger, logger)
+
+
+@contextlib.contextmanager
+def traced_operation(
+    logger: structlog.stdlib.BoundLogger,
+    operation: str,
+    *,
+    object_id: str | None = None,
+    correlation_id: str | None = None,
+    **fields: object,
+) -> Iterator[TraceResult]:
+    correlation = correlation_id or str(uuid4())
+    start = time.perf_counter()
+    bound = logger.bind(
+        operation=operation,
+        object_id=object_id,
+        correlation_id=correlation,
+        **fields,
+    )
+    bound.info("operation_started", status="started")
+    try:
+        yield TraceResult(correlation_id=correlation, latency_ms=0.0)
+    except Exception:
+        latency_ms = (time.perf_counter() - start) * 1000
+        bound.exception("operation_failed", status="error", latency=latency_ms)
+        raise
+    else:
+        latency_ms = (time.perf_counter() - start) * 1000
+        bound.info("operation_finished", status="ok", latency=latency_ms)

synap_git/diagnostics/tracing.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+
+class TraceStore:
+    """Manages recording and retrieving the latest operational trace."""
+
+    def __init__(self, repository_path: Path) -> None:
+        self.repo_path = repository_path
+        self.trace_file = repository_path / ".synap" / "trace_latest.json"
+
+    def record_trace(
+        self,
+        trace_type: str,
+        summary: str,
+        details: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Save a new trace event as the latest trace."""
+        import uuid
+
+        trace_id = str(uuid.uuid4())
+        trace_data = {
+            "trace_id": trace_id,
+            "timestamp": datetime.now(UTC).isoformat(),
+            "type": trace_type,
+            "summary": summary,
+            "details": details,
+        }
+
+        try:
+            self.trace_file.parent.mkdir(parents=True, exist_ok=True)
+            self.trace_file.write_text(json.dumps(trace_data, indent=2), encoding="utf-8")
+        except Exception:
+            # Operational stability: do not crash the app if trace file cannot be written
+            pass
+
+        return trace_data
+
+    def get_latest(self) -> dict[str, Any]:
+        """Retrieve the latest trace event."""
+        if not self.trace_file.exists():
+            return {
+                "trace_id": "none",
+                "timestamp": datetime.now(UTC).isoformat(),
+                "type": "system",
+                "summary": "No traces recorded yet",
+                "details": {
+                    "status": "ready",
+                    "message": "Tracing system initialized. Waiting for retrieval/indexing activity.",
+                },
+            }
+
+        try:
+            data = json.loads(self.trace_file.read_text(encoding="utf-8"))
+            if isinstance(data, dict):
+                import typing
+
+                return typing.cast(dict[str, Any], data)
+            return {"error": "Invalid trace structure"}
+        except Exception as e:
+            return {
+                "trace_id": "error",
+                "timestamp": datetime.now(UTC).isoformat(),
+                "type": "error",
+                "summary": "Failed to read latest trace",
+                "details": {"error": str(e)},
+            }

synap_git/git/__init__.py

@@ -0,0 +1,11 @@
+"""Git state inspection for context commits."""
+
+from synap_git.git.state import (
+    GitChange,
+    GitChangeKind,
+    GitIntegrationError,
+    GitRepository,
+    GitState,
+)
+
+__all__ = ["GitChange", "GitChangeKind", "GitIntegrationError", "GitRepository", "GitState"]

synap_git/git/state.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+from typing import Any
+
+
+class GitIntegrationError(RuntimeError):
+    """Raised when Git state cannot be inspected."""
+
+
+class GitChangeKind(StrEnum):
+    INITIAL = "initial"
+    COMMIT = "commit"
+    CHECKOUT = "checkout"
+    BRANCH = "branch"
+    MERGE = "merge"
+    REBASE = "rebase"
+    REVERT = "revert"
+    UNCHANGED = "unchanged"
+
+
+@dataclass(frozen=True)
+class GitState:
+    repository_path: Path
+    is_repository: bool
+    head_commit: str | None = None
+    branch: str | None = None
+    is_dirty: bool = False
+    is_detached: bool = False
+    merge_in_progress: bool = False
+    rebase_in_progress: bool = False
+    commit_parent_hashes: tuple[str, ...] = ()
+    commit_message: str | None = None
+
+    @property
+    def effective_branch(self) -> str:
+        return self.branch or "detached"
+
+
+@dataclass(frozen=True)
+class GitChange:
+    kind: GitChangeKind
+    previous: GitState | None
+    current: GitState
+
+
+class GitRepository:
+    """Thin GitPython-backed reader for repository lineage state."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path
+
+    def state(self) -> GitState:
+        try:
+            from git import InvalidGitRepositoryError, NoSuchPathError, Repo
+        except ImportError as exc:
+            raise GitIntegrationError("GitPython is not installed") from exc
+
+        try:
+            repo: Any = Repo(self.path, search_parent_directories=True)
+        except (InvalidGitRepositoryError, NoSuchPathError):
+            return GitState(repository_path=self.path.resolve(), is_repository=False)
+
+        repository_path = Path(repo.working_tree_dir or self.path).resolve()
+        git_dir = Path(repo.git_dir)
+        is_detached = bool(repo.head.is_detached)
+        branch: str | None
+        if is_detached:
+            branch = None
+        else:
+            branch = str(repo.active_branch.name)
+
+        head_commit: str | None = None
+        parent_hashes: tuple[str, ...] = ()
+        commit_message: str | None = None
+        try:
+            commit = repo.head.commit
+            head_commit = str(commit.hexsha)
+            parent_hashes = tuple(str(parent.hexsha) for parent in commit.parents)
+            commit_message = str(commit.message).strip()
+        except ValueError:
+            pass
+
+        return GitState(
+            repository_path=repository_path,
+            is_repository=True,
+            head_commit=head_commit,
+            branch=branch,
+            is_dirty=bool(repo.is_dirty(untracked_files=True)),
+            is_detached=is_detached,
+            merge_in_progress=(git_dir / "MERGE_HEAD").exists(),
+            rebase_in_progress=(git_dir / "rebase-merge").exists()
+            or (git_dir / "rebase-apply").exists(),
+            commit_parent_hashes=parent_hashes,
+            commit_message=commit_message,
+        )
+
+    @staticmethod
+    def classify(previous: GitState | None, current: GitState) -> GitChange:
+        if previous is None:
+            return GitChange(kind=GitChangeKind.INITIAL, previous=None, current=current)
+        if current.rebase_in_progress and not previous.rebase_in_progress:
+            return GitChange(kind=GitChangeKind.REBASE, previous=previous, current=current)
+        if current.merge_in_progress and not previous.merge_in_progress:
+            return GitChange(kind=GitChangeKind.MERGE, previous=previous, current=current)
+        if previous.branch != current.branch:
+            return GitChange(kind=GitChangeKind.BRANCH, previous=previous, current=current)
+        if previous.head_commit != current.head_commit:
+            message = current.commit_message or ""
+            if message.startswith("Revert "):
+                return GitChange(kind=GitChangeKind.REVERT, previous=previous, current=current)
+
+            try:
+                from git import Repo
+
+                repo = Repo(current.repository_path)
+                curr_commit = repo.head.commit
+                curr_tree = curr_commit.tree.hexsha
+                is_revert = False
+                for parent in curr_commit.parents:
+                    for ancestor in repo.iter_commits(parent, max_count=20):
+                        if ancestor.tree.hexsha == curr_tree:
+                            is_revert = True
+                            break
+                    if is_revert:
+                        break
+                if is_revert:
+                    return GitChange(kind=GitChangeKind.REVERT, previous=previous, current=current)
+            except Exception:
+                pass
+
+            if len(current.commit_parent_hashes) > 1:
+                return GitChange(kind=GitChangeKind.MERGE, previous=previous, current=current)
+            return GitChange(kind=GitChangeKind.COMMIT, previous=previous, current=current)
+        if previous.is_detached != current.is_detached:
+            return GitChange(kind=GitChangeKind.CHECKOUT, previous=previous, current=current)
+        return GitChange(kind=GitChangeKind.UNCHANGED, previous=previous, current=current)

synap_git/indexer/daemon.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import asyncio
+import signal
+import time
+from dataclasses import dataclass
+
+from synap_git.config import SynapSettings
+from synap_git.diagnostics.logger import get_logger
+from synap_git.git import GitRepository, GitState
+from synap_git.indexer.engine import SynapRuntime
+
+
+@dataclass(frozen=True)
+class DaemonHealth:
+    running: bool
+    active_commit: str | None
+    branch: str
+
+
+class RuntimeDaemon:
+    """Simplified long-running local daemon with Git-aware indexing."""
+
+    def __init__(self, settings: SynapSettings) -> None:
+        self.settings = settings
+        self.runtime = SynapRuntime(settings)
+        self.git = GitRepository(settings.repository_path)
+        self.logger = get_logger("daemon")
+        self._stop_event = asyncio.Event()
+        self._last_git_state: GitState | None = None
+        self._running = False
+
+    async def start(self) -> None:
+        self.runtime.initialize_storage()
+        self._uptime_start = time.time()
+        self._recovery_attempts = 0
+
+        # Initial bootstrap
+        await asyncio.to_thread(self.runtime.bootstrap)
+
+        self._running = True
+        self._write_heartbeat(status="healthy")
+        self._install_signal_handlers()
+        try:
+            await self._poll_git_loop()
+        finally:
+            self._running = False
+            self._delete_heartbeat()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+
+    def health(self) -> DaemonHealth:
+        status = self.runtime.status()
+        return DaemonHealth(
+            running=self._running,
+            active_commit=status.active_commit,
+            branch=status.branch,
+        )
+
+    def _write_heartbeat(self, status: str = "healthy", last_error: str | None = None) -> None:
+        import json
+        import os
+        import time as time_lib
+        from datetime import UTC, datetime
+
+        heartbeat_file = self.settings.repository_path / ".synap" / "daemon_heartbeat.json"
+        heartbeat_file.parent.mkdir(parents=True, exist_ok=True)
+
+        uptime = int(time_lib.time() - self._uptime_start) if hasattr(self, "_uptime_start") else 0
+
+        data = {
+            "pid": os.getpid(),
+            "timestamp": datetime.now(UTC).isoformat(),
+            "status": status,
+            "uptime_seconds": uptime,
+            "recovery_attempts": getattr(self, "_recovery_attempts", 0),
+            "last_error": last_error,
+            "branch": self._last_git_state.effective_branch if self._last_git_state else "unknown",
+            "active_commit": self._last_git_state.head_commit
+            if self._last_git_state
+            else "unknown",
+        }
+        try:
+            heartbeat_file.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        except Exception:
+            pass
+
+    def _delete_heartbeat(self) -> None:
+        heartbeat_file = self.settings.repository_path / ".synap" / "daemon_heartbeat.json"
+        if heartbeat_file.exists():
+            try:
+                heartbeat_file.unlink()
+            except Exception:
+                pass
+
+    async def _poll_git_loop(self) -> None:
+        while not self._stop_event.is_set():
+            try:
+                state = self.git.state()
+                change = self.git.classify(self._last_git_state, state)
+                self._last_git_state = state
+
+                if change.kind == "commit":
+                    self.logger.info("git_commit_detected")
+                    await asyncio.to_thread(self.runtime.handle_commit, state)
+                elif change.kind in ("branch", "checkout"):
+                    self.logger.info("git_branch_switch_detected")
+                    await asyncio.to_thread(self.runtime.handle_branch_switch, state)
+                elif change.kind == "merge":
+                    self.logger.info("git_merge_detected")
+                    await asyncio.to_thread(self.runtime.handle_merge, state)
+                elif change.kind == "revert":
+                    self.logger.info("git_revert_detected")
+                    await asyncio.to_thread(self.runtime.handle_revert, self._last_git_state, state)
+                elif change.kind not in ("initial", "unchanged"):
+                    self.logger.info("git_change_detected", kind=change.kind)
+                    await asyncio.to_thread(self.runtime.index_repository, git_state=state)
+
+                self._write_heartbeat(status="healthy")
+            except Exception as e:
+                self.logger.error("daemon_loop_error", error=str(e))
+                self._recovery_attempts += 1
+                self._write_heartbeat(status="degraded", last_error=str(e))
+
+                # Database recovery if corrupted
+                try:
+                    is_wiped = await asyncio.to_thread(self.runtime.store.recover_if_corrupted)
+                    if is_wiped:
+                        self.logger.warning("daemon_rebuilding_corrupted_db")
+                        await asyncio.to_thread(self.runtime.bootstrap, force=True)
+                except Exception as ex:
+                    self.logger.error("daemon_self_healing_failed", error=str(ex))
+
+            await asyncio.sleep(self.settings.daemon_poll_interval_seconds)
+
+    def _install_signal_handlers(self) -> None:
+        loop = asyncio.get_running_loop()
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            try:
+                loop.add_signal_handler(sig, self.stop)
+            except NotImplementedError:
+                continue