batho 0.1.4__py3-none-any.whl

batho/__init__.py

@@ -0,0 +1,55 @@
+"""
+Batho Core - Code analysis and indexing library.
+
+This package provides the core functionality for analyzing code repositories,
+building dependency graphs, and generating contextual information for LLMs.
+"""
+
+__version__ = "0.1.3"
+
+from batho.config import get_config_cached, reload_config
+from batho.context.bsg_map import BSGMap
+
+# Import and re-export public APIs from submodules
+from batho.context.codegraph import CodeGraphIndexer, InMemoryGraph
+from batho.context.incremental import get_changed_file_status_since
+from batho.context.query import QueryService
+from batho.time_machine import (
+    FileChange,
+    FileChangeSummary,
+    FileChangeTracker,
+    FileChangeType,
+    create_snapshot,
+    diff_snapshots,
+    incremental_patch,
+    list_snapshots,
+    load_snapshot,
+)
+from batho.utils.logging import get_logger
+
+__all__ = [
+    # Core indexing
+    "CodeGraphIndexer",
+    "InMemoryGraph",
+    # Query service
+    "QueryService",
+    # BSG rendering
+    "BSGMap",
+    # Incremental
+    "get_changed_file_status_since",
+    # Time machine
+    "create_snapshot",
+    "diff_snapshots",
+    "FileChange",
+    "FileChangeSummary",
+    "FileChangeTracker",
+    "FileChangeType",
+    "incremental_patch",
+    "list_snapshots",
+    "load_snapshot",
+    # Config
+    "get_config_cached",
+    "reload_config",
+    # Logging
+    "get_logger",
+]

batho/bridge/__init__.py

@@ -0,0 +1,42 @@
+"""Batho bridge — access .ctn artifacts via registry, REST, and MCP."""
+
+from __future__ import annotations
+
+from batho.bridge.artifact_loader import (
+    ArtifactContent,
+    ArtifactLoader,
+    ArtifactNotFoundError,
+    ArtifactParseError,
+    ChecksumMismatchError,
+)
+from batho.bridge.http_api import BridgeAPIHandler, create_bridge_server
+from batho.bridge.mcp_server import create_mcp_server, run_mcp_sse, run_mcp_stdio
+from batho.bridge.models import (
+    ArtifactRecord,
+    BridgeErrorResponse,
+    BridgeResponse,
+    IndexEntry,
+    RegistryStats,
+)
+from batho.bridge.registry_client import ArtifactRegistryBridge
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "ArtifactContent",
+    "ArtifactLoader",
+    "ArtifactNotFoundError",
+    "ArtifactParseError",
+    "ArtifactRecord",
+    "ArtifactRegistryBridge",
+    "BridgeAPIHandler",
+    "BridgeErrorResponse",
+    "BridgeResponse",
+    "ChecksumMismatchError",
+    "IndexEntry",
+    "RegistryStats",
+    "create_bridge_server",
+    "create_mcp_server",
+    "run_mcp_sse",
+    "run_mcp_stdio",
+]

batho/bridge/artifact_loader.py

@@ -0,0 +1,214 @@
+"""Artifact loader — resolves paths and loads JSON content from .ctn artifacts."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from batho.bridge.constants import DEFAULT_PATH_PATTERNS, INDEX_SCOPED_TYPES
+from batho.bridge.models import ArtifactRecord
+from batho.bridge.registry_client import ArtifactRegistryBridge
+from batho.utils.hash import compute_file_hash
+from batho.utils.logging import get_logger
+
+LOGGER = get_logger(__name__, component="bridge")
+
+
+class ArtifactNotFoundError(Exception):
+    """Raised when an artifact cannot be resolved on disk."""
+
+    def __init__(self, artifact_type: str, resolved_path: str) -> None:
+        super().__init__(f"Artifact not found: {artifact_type} at {resolved_path}")
+        self.artifact_type = artifact_type
+        self.resolved_path = resolved_path
+
+
+class ChecksumMismatchError(Exception):
+    """Raised when the on-disk checksum does not match the registry."""
+
+    def __init__(self, artifact_type: str, expected: str, actual: str) -> None:
+        super().__init__(
+            f"Checksum mismatch for {artifact_type}: expected {expected}, got {actual}"
+        )
+        self.artifact_type = artifact_type
+        self.expected = expected
+        self.actual = actual
+
+
+class ArtifactParseError(Exception):
+    """Raised when JSON parsing fails."""
+
+    def __init__(self, artifact_type: str, path: str, message: str) -> None:
+        super().__init__(f"Parse error in {artifact_type} ({path}): {message}")
+        self.artifact_type = artifact_type
+        self.path = path
+
+
+@dataclass
+class ArtifactContent:
+    """Loaded artifact with metadata."""
+
+    record: ArtifactRecord
+    data: dict[str, Any]
+    resolved_path: str
+    checksum_verified: bool
+
+
+class ArtifactLoader:
+    """Resolves artifact paths and loads JSON content with fallbacks."""
+
+    def __init__(self, ctn_dir: Path) -> None:
+        self.ctn_dir = ctn_dir.resolve()
+        self._bridge = ArtifactRegistryBridge(self.ctn_dir)
+
+    def _resolve_index_id(self) -> str | None:
+        """Return the current index_id from index.json, if any."""
+        latest = self._bridge.get_latest_index()
+        return latest.index_id if latest else None
+
+    def _resolve_path(self, artifact_type: str, index_id: str | None = None) -> Path | None:
+        """Resolve the filesystem path for an artifact type.
+
+        Resolution order:
+        1. Registry lookup by type (most recent active artifact).
+        2. Default pattern using provided or current index_id.
+        3. index.json ``outputs`` map lookup.
+        """
+        # 1. Registry lookup
+        candidates = self._bridge.get_artifacts_by_type(artifact_type, limit=1)
+        if candidates:
+            record = candidates[0]
+            phys = Path(record.physical_path)
+            if phys.exists():
+                return phys
+            logical = self.ctn_dir / record.logical_path
+            if logical.exists():
+                return logical
+
+        # 2. Default pattern
+        pattern = DEFAULT_PATH_PATTERNS.get(artifact_type)
+        if pattern:
+            if artifact_type in INDEX_SCOPED_TYPES:
+                idx = index_id or self._resolve_index_id()
+                if idx:
+                    resolved = self.ctn_dir / pattern.format(index_id=idx)
+                    if resolved.exists():
+                        return resolved
+            else:
+                resolved = self.ctn_dir / pattern
+                if resolved.exists():
+                    return resolved
+
+        # 3. index.json outputs map
+        latest = self._bridge.get_latest_index()
+        if latest and latest.outputs:
+            output_key = _artifact_type_to_output_key(artifact_type)
+            if output_key:
+                rel_path = latest.outputs.get(output_key)
+                if rel_path:
+                    candidate = (self.ctn_dir.parent / rel_path).resolve()
+                    if candidate.exists():
+                        return candidate
+                    # Try relative to ctn_dir itself
+                    candidate2 = self.ctn_dir / rel_path
+                    if candidate2.exists():
+                        return candidate2
+
+        return None
+
+    def load_json(
+        self,
+        artifact_type: str,
+        *,
+        index_id: str | None = None,
+        verify_checksum: bool = True,
+    ) -> dict[str, Any]:
+        """Load and return the JSON content for an artifact type.
+
+        Raises:
+            ArtifactNotFoundError: if no file can be resolved.
+            ChecksumMismatchError: if checksum verification fails.
+            ArtifactParseError: if JSON parsing fails.
+        """
+        path = self._resolve_path(artifact_type, index_id=index_id)
+        if path is None or not path.exists():
+            raise ArtifactNotFoundError(artifact_type, str(path) if path else "<unresolved>")
+
+        # Checksum verification
+        record: ArtifactRecord | None = None
+        candidates = self._bridge.get_artifacts_by_type(artifact_type, limit=1)
+        if candidates:
+            record = candidates[0]
+
+        checksum_verified = False
+        if verify_checksum and record and record.checksum:
+            actual = compute_file_hash(path) or ""
+            if actual and actual != record.checksum:
+                raise ChecksumMismatchError(artifact_type, record.checksum, actual)
+            checksum_verified = actual == record.checksum
+
+        # Load JSON
+        try:
+            raw = path.read_text(encoding="utf-8")
+            data: dict[str, Any] = json.loads(raw)
+        except (OSError, json.JSONDecodeError) as exc:
+            raise ArtifactParseError(artifact_type, str(path), str(exc))
+
+        if not isinstance(data, dict):
+            raise ArtifactParseError(artifact_type, str(path), "top-level value is not an object")
+
+        return data
+
+    def load_artifact(self, record: ArtifactRecord, *, verify_checksum: bool = True) -> ArtifactContent:
+        """Load a specific artifact by its registry record."""
+        path = Path(record.physical_path)
+        if not path.exists():
+            path = self.ctn_dir / record.logical_path
+        if not path.exists():
+            raise ArtifactNotFoundError(record.artifact_type, str(record.physical_path))
+
+        checksum_verified = False
+        if verify_checksum and record.checksum:
+            actual = compute_file_hash(path) or ""
+            if actual and actual != record.checksum:
+                raise ChecksumMismatchError(record.artifact_type, record.checksum, actual)
+            checksum_verified = actual == record.checksum
+
+        try:
+            raw = path.read_text(encoding="utf-8")
+            data = json.loads(raw)
+        except (OSError, json.JSONDecodeError) as exc:
+            raise ArtifactParseError(record.artifact_type, str(path), str(exc))
+
+        if not isinstance(data, dict):
+            raise ArtifactParseError(record.artifact_type, str(path), "top-level value is not an object")
+
+        return ArtifactContent(
+            record=record,
+            data=data,
+            resolved_path=str(path),
+            checksum_verified=checksum_verified,
+        )
+
+
+def _artifact_type_to_output_key(artifact_type: str) -> str | None:
+    """Map artifact types to keys used in index.json ``outputs``."""
+    mapping = {
+        "graph_json": "graph_json",
+        "bsg_json": "bsg_json",
+        "context_overview_json": "overview_json",
+        "context_files_json": "files_json",
+    }
+    return mapping.get(artifact_type)
+
+
+__all__ = [
+    "ArtifactLoader",
+    "ArtifactContent",
+    "ArtifactNotFoundError",
+    "ChecksumMismatchError",
+    "ArtifactParseError",
+]

batho/bridge/constants.py

@@ -0,0 +1,79 @@
+"""Artifact type constants and path mappings for the Batho bridge."""
+
+from __future__ import annotations
+
+# Artifact types that the bridge can load as JSON
+KNOWN_ARTIFACT_TYPES: set[str] = {
+    "interception_stats_json",
+    "graph_json",
+    "bsg_json",
+    "context_overview_json",
+    "context_files_json",
+    "snapshot_json",
+    "index_metadata",
+    "metrics_json",
+    "file_hashes_json",
+    "patches_index",
+    "patch_detail",
+}
+
+# Default logical path patterns relative to .ctn/ for each artifact type.
+# The {index_id} placeholder is resolved from the current index.
+DEFAULT_PATH_PATTERNS: dict[str, str] = {
+    "interception_stats_json": "local/metrics/interception_stats.json",
+    "graph_json": "{index_id}/graph.json",
+    "bsg_json": "{index_id}/bsg.json",
+    "context_overview_json": "{index_id}/context/json/overview.json",
+    "context_files_json": "{index_id}/context/json/files.json",
+    "snapshot_json": "snapshots/{name}.json",
+    "index_metadata": "index.json",
+    "metrics_json": "local/metrics/metrics.json",
+    "file_hashes_json": "local/state/file_hashes.json",
+    "patches_index": "patches/index.json",
+    "patch_detail": "patches/patch_{operation_id}.json",
+}
+
+# Artifact types that require an index_id for path resolution
+INDEX_SCOPED_TYPES: set[str] = {
+    "graph_json",
+    "bsg_json",
+    "context_overview_json",
+    "context_files_json",
+}
+
+# Registry column names exposed by the bridge API
+ARTIFACT_RECORD_FIELDS: tuple[str, ...] = (
+    "artifact_id",
+    "content_id",
+    "artifact_type",
+    "logical_path",
+    "physical_path",
+    "checksum",
+    "size_bytes",
+    "schema_version",
+    "producer",
+    "run_id",
+    "sync_status",
+    "cloud_content_id",
+    "last_sync_at",
+    "sync_error",
+    "retry_count",
+    "retention_class",
+    "metadata",
+    "created_at",
+    "updated_at",
+)
+
+DEFAULT_BRIDGE_HTTP_PORT = 8766
+DEFAULT_MCP_SSE_PORT = 8767
+DEFAULT_PAGE_LIMIT = 200
+
+__all__ = [
+    "KNOWN_ARTIFACT_TYPES",
+    "DEFAULT_PATH_PATTERNS",
+    "INDEX_SCOPED_TYPES",
+    "ARTIFACT_RECORD_FIELDS",
+    "DEFAULT_BRIDGE_HTTP_PORT",
+    "DEFAULT_MCP_SSE_PORT",
+    "DEFAULT_PAGE_LIMIT",
+]