core-runtime 0.1.1__py3-none-any.whl

body/maintenance/memory_cleanup_service.py

@@ -0,0 +1,131 @@
+# src/body/maintenance/memory_cleanup_service.py
+
+"""
+Memory cleanup service - business logic for retention policies.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+from sqlalchemy import text
+
+from shared.action_types import ActionImpact, ActionResult
+from shared.atomic_action import atomic_action
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.infrastructure.repositories.memory_repository import MemoryRepository
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+_CFG_MEM = load_operational_config().memory
+
+
+# ID: f81e034c-23d7-44d5-b7df-58c5a14e06e0
+class MemoryCleanupService:
+    """
+    Implements retention policies for agent memory and action ledgers.
+    """
+
+    def __init__(self, session):
+        self.session = session
+        self.repository = MemoryRepository(session)
+
+    @atomic_action(
+        action_id="cleanup.agent_memory",
+        intent="Execute memory retention policy",
+        impact=ActionImpact.WRITE_DATA,
+        policies=["atomic_actions"],
+    )
+    # ID: e9fa0b0e-2054-41ab-bd37-277efa5992c6
+    async def cleanup_old_memories(
+        self,
+        days_to_keep_episodes: int = _CFG_MEM.episode_retention_days,
+        days_to_keep_reflections: int = _CFG_MEM.reflection_retention_days,
+        dry_run: bool = True,
+        **kwargs,
+    ) -> ActionResult:
+        """
+        Execute agent memory retention policy.
+        """
+        cutoff_episodes = datetime.utcnow() - timedelta(days=days_to_keep_episodes)
+        cutoff_reflections = datetime.utcnow() - timedelta(
+            days=days_to_keep_reflections
+        )
+
+        try:
+            if dry_run:
+                episodes_count = await self.repository.count_episodes_older_than(
+                    cutoff_episodes
+                )
+                reflections_count = await self.repository.count_reflections_older_than(
+                    cutoff_reflections
+                )
+            else:
+                episodes_count = await self.repository.delete_old_episodes(
+                    cutoff_episodes
+                )
+                reflections_count = await self.repository.delete_old_reflections(
+                    cutoff_reflections
+                )
+
+            return ActionResult(
+                action_id="cleanup.agent_memory",
+                ok=True,
+                data={
+                    "episodes_deleted": episodes_count,
+                    "reflections_deleted": reflections_count,
+                    "dry_run": dry_run,
+                },
+            )
+
+        except Exception as e:
+            logger.error("Memory cleanup failed: %s", e)
+            return ActionResult(
+                action_id="cleanup.agent_memory", ok=False, data={"error": str(e)}
+            )
+
+    @atomic_action(
+        action_id="cleanup.action_results",
+        intent="Prune old operational action results",
+        impact=ActionImpact.WRITE_DATA,
+        policies=["atomic_actions"],
+    )
+    # ID: 5e76777a-ca1d-424f-9853-acbee0967c6e
+    async def cleanup_action_results(
+        self, days_to_keep: int = 7, dry_run: bool = True, **kwargs
+    ) -> ActionResult:
+        """
+        Removes old records from core.action_results to keep the ledger relevant.
+        """
+        cutoff = datetime.utcnow() - timedelta(days=days_to_keep)
+
+        try:
+            if dry_run:
+                query = text(
+                    "SELECT COUNT(*) FROM core.action_results WHERE created_at < :cutoff"
+                )
+                res = await self.session.execute(query, {"cutoff": cutoff})
+                count = res.scalar_one()
+            else:
+                query = text(
+                    "DELETE FROM core.action_results WHERE created_at < :cutoff"
+                )
+                res = await self.session.execute(query, {"cutoff": cutoff})
+                count = res.rowcount
+
+            return ActionResult(
+                action_id="cleanup.action_results",
+                ok=True,
+                data={
+                    "records_processed": count,
+                    "dry_run": dry_run,
+                    "retention_days": days_to_keep,
+                },
+            )
+        except Exception as e:
+            logger.error("Action results cleanup failed: %s", e)
+            return ActionResult(
+                action_id="cleanup.action_results", ok=False, data={"error": str(e)}
+            )

body/maintenance/refactor_settings_access.py

@@ -0,0 +1,274 @@
+# src/body/maintenance/refactor_settings_access.py
+
+"""
+Constitutional Settings Access Refactoring
+
+Automates migration from scattered `settings` imports to DI via CoreContext.
+
+Strategy:
+1. Detect direct settings imports in Mind/Will layers
+2. Add context parameter to constructors/functions
+3. Replace settings.X with context.X or receive via parameter
+4. Update callers to pass context
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from shared.infrastructure.storage.file_handler import FileHandler
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+@dataclass
+# ID: 4147dd2f-0ad1-4c14-aba4-51556a918ae5
+class SettingsUsage:
+    file_path: Path
+    import_line: int
+    usages: list[tuple[int, str]]
+    has_constructor: bool
+    constructor_line: int | None
+    is_typer_command: bool
+    function_def_line: int | None
+
+
+@dataclass
+# ID: 1a68f49a-0093-4e64-b46a-a0e98fbaf312
+class RefactorPlan:
+    file_path: Path
+    remove_import: int
+    add_context_param: int | None
+    replacements: list[tuple[int, str, str]]
+    is_typer_command: bool
+
+
+# ID: 8639661b-33ee-4e8a-8a99-4857139f0d19
+class SettingsRefactorer:
+    SETTINGS_PATTERN = re.compile(r"from shared\.config import (?:settings|Settings)")
+    USAGE_PATTERN = re.compile(r"settings\.(\w+)")
+
+    def __init__(self, repo_path: Path, file_handler: FileHandler):
+        self.repo_path = repo_path
+        self.file_handler = file_handler
+
+    # ID: caee3565-c3a7-406c-bce1-2fadbc1f5c54
+    def analyze_file(self, file_path: Path) -> SettingsUsage | None:
+        try:
+            content = file_path.read_text()
+            lines = content.splitlines()
+        except Exception:
+            return None
+
+        # Find import
+        import_line = None
+        for i, line in enumerate(lines, 1):
+            if self.SETTINGS_PATTERN.search(line):
+                import_line = i
+                break
+        if not import_line:
+            return None
+
+        # Find usages
+        usages = []
+        for i, line in enumerate(lines, 1):
+            for match in self.USAGE_PATTERN.finditer(line):
+                attr = match.group(1)
+                usages.append((i, attr))
+
+        # Context detection
+        has_constructor, constructor_line = self._find_constructor(lines)
+        is_typer_command, func_line = self._find_typer_command(lines)
+
+        return SettingsUsage(
+            file_path=file_path,
+            import_line=import_line,
+            usages=usages,
+            has_constructor=has_constructor,
+            constructor_line=constructor_line,
+            is_typer_command=is_typer_command,
+            function_def_line=func_line,
+        )
+
+    def _find_constructor(self, lines: list[str]) -> tuple[bool, int | None]:
+        for i, line in enumerate(lines, 1):
+            if re.match(r"\s*def __init__\(", line):
+                return True, i
+        return False, None
+
+    def _find_typer_command(self, lines: list[str]) -> tuple[bool, int | None]:
+        for i, line in enumerate(lines, 1):
+            # Heuristic for Typer command
+            if "@app.command" in line or "@core_command" in line or "async def" in line:
+                if "ctx: typer.Context" in line or "ctx: Context" in line:
+                    return True, i
+        return False, None
+
+    # ID: 5d655333-f3cc-4bf9-85ea-af221a58134f
+    def create_refactor_plan(self, usage: SettingsUsage) -> RefactorPlan:
+        replacements = []
+
+        # CLI Command Mapping (via ctx.obj)
+        CLI_MAP = {
+            "REPO_PATH": "core_context.git_service.repo_path",
+            "MIND": "core_context.path_resolver.intent_root",
+            "DATABASE_URL": "settings.DATABASE_URL",  # Fallback, likely won't work perfectly
+        }
+
+        # Class/Func Mapping (via injected context)
+        CLASS_MAP = {
+            "REPO_PATH": "context.git_service.repo_path",
+            "MIND": "context.path_resolver.intent_root",
+        }
+
+        mapping = CLI_MAP if usage.is_typer_command else CLASS_MAP
+        prefix = "" if usage.is_typer_command else "context."
+
+        for line_num, attr in usage.usages:
+            old_expr = f"settings.{attr}"
+            # Default to accessing via settings property if not mapped
+            new_expr = mapping.get(attr, f"{prefix}settings.{attr}")
+            replacements.append((line_num, old_expr, new_expr))
+
+        add_at = None
+        if usage.has_constructor:
+            add_at = usage.constructor_line
+        elif not usage.is_typer_command:
+            # Add param to function if not a CLI command (which has ctx)
+            # Find first function
+            content = usage.file_path.read_text()
+            match = re.search(r"^def \w+\(", content, re.MULTILINE)
+            if match:
+                # Approximate line number calculation would be needed here
+                # For now we rely on constructor logic or manual fix for complex functions
+                pass
+
+        return RefactorPlan(
+            file_path=usage.file_path,
+            remove_import=usage.import_line,
+            add_context_param=add_at,
+            replacements=replacements,
+            is_typer_command=usage.is_typer_command,
+        )
+
+    # ID: d0a64412-9931-45af-b6fc-65356bf7b791
+    def apply_refactor(self, plan: RefactorPlan, dry_run: bool = True) -> bool:
+        try:
+            content = plan.file_path.read_text()
+            lines = content.splitlines()
+
+            # 1. Comment out import
+            lines[plan.remove_import - 1] = (
+                "# REFACTORED: Removed direct settings import"
+            )
+
+            # 2. Add Context extraction for CLI commands
+            if plan.is_typer_command:
+                # Heuristic: Find where to inject 'core_context = ctx.obj'
+                # Look for the function def line
+                for i, line in enumerate(lines):
+                    if "def " in line and "ctx" in line:
+                        # Insert initialization at start of function body
+                        indent = "    "  # Assume 4 spaces
+                        lines.insert(
+                            i + 1, f"{indent}core_context: CoreContext = ctx.obj"
+                        )
+                        lines.insert(
+                            i + 1, f"{indent}from shared.context import CoreContext"
+                        )  # Lazy import
+                        break
+
+            # 3. Apply Replacements
+            for line_num, old, new in plan.replacements:
+                # Adjust line num for inserted lines
+                # This is tricky without tracking offsets.
+                # Simplification: We scan for the content match.
+                for i, line in enumerate(lines):
+                    if old in line:
+                        lines[i] = line.replace(old, new)
+
+            new_content = "\n".join(lines) + "\n"
+
+            if dry_run:
+                logger.info("DRY RUN: Refactoring %s", plan.file_path)
+                return True
+
+            rel_path = str(plan.file_path.relative_to(self.repo_path))
+            self.file_handler.write_runtime_text(rel_path, new_content)
+            logger.info("✅ Refactored %s", rel_path)
+            return True
+
+        except Exception as e:
+            logger.error("Failed to refactor %s: %s", plan.file_path, e)
+            return False
+
+    # ID: 12bbf24c-c18b-4dec-b205-3c91acb7872f
+    def refactor_layer(self, layer: str, dry_run: bool = True) -> dict[str, Any]:
+        """Refactor all files in a layer (mind, will, body)."""
+        layer_path = self.repo_path / "src" / layer
+        if not layer_path.exists():
+            return {"error": f"Layer {layer} not found"}
+
+        results = {
+            "analyzed": 0,
+            "planned": 0,
+            "refactored": 0,
+            "failed": 0,
+            "files": [],
+        }
+
+        # Find all Python files
+        for py_file in layer_path.rglob("*.py"):
+            if "__pycache__" in str(py_file):
+                continue
+
+            results["analyzed"] += 1
+
+            # Analyze
+            usage = self.analyze_file(py_file)
+            if not usage:
+                continue
+
+            logger.info(
+                "Found settings usage in %s", py_file.relative_to(self.repo_path)
+            )
+            results["planned"] += 1
+
+            # Create plan
+            plan = self.create_refactor_plan(usage)
+
+            # Apply
+            if self.apply_refactor(plan, dry_run=dry_run):
+                results["refactored"] += 1
+                results["files"].append(str(py_file.relative_to(self.repo_path)))
+            else:
+                results["failed"] += 1
+
+        return results
+
+
+# ID: e23d9e3e-fc3f-4818-880a-90118a32770d
+async def refactor_settings_access(
+    repo_path: Path, layers: list[str] | None = None, dry_run: bool = True
+) -> dict[str, Any]:
+    if layers is None:
+        layers = ["body", "mind", "will"]
+
+    file_handler = FileHandler(str(repo_path))
+    refactorer = SettingsRefactorer(repo_path, file_handler)
+
+    # We iterate all layers now since we handle CLI commands
+    all_results = {}
+    for layer in layers:
+        # Custom logic to recursively find files
+        pass  # (Reuse existing logic or standard glob)
+        # For brevity, reusing the class logic:
+        res = refactorer.refactor_layer(layer, dry_run)
+        all_results[layer] = res
+
+    return all_results

body/maintenance/scripts/__init__.py

@@ -0,0 +1,5 @@
+# src/body/maintenance/scripts/__init__.py
+
+"""Provides functionality for the __init__ module."""
+
+from __future__ import annotations

body/maintenance/scripts/context_export.py

@@ -0,0 +1,278 @@
+# src/body/maintenance/scripts/context_export.py
+
+"""
+Export a complete, compact operational snapshot of CORE.
+Refactored to use canonical services (FileHandler, GitService, Settings).
+"""
+
+from __future__ import annotations
+
+import ast
+import asyncio
+import dataclasses
+import hashlib
+import io
+import json
+import tarfile
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from shared.infrastructure.git_service import GitService
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.infrastructure.storage.file_handler import FileHandler
+from shared.logger import getLogger
+from shared.time import now_iso
+
+if TYPE_CHECKING:
+    from shared.context import CoreContext
+
+
+_CFG = load_operational_config().misc
+
+
+logger = getLogger(__name__)
+
+
+@dataclasses.dataclass
+# ID: fc33426e-cb3d-461d-b20f-a02b90f2408f
+class Symbol:
+    module: str
+    kind: str
+    name: str
+    lineno: int
+    signature: str
+    doc: str | None
+
+
+# ---------------------------
+# Helpers
+# ---------------------------
+
+
+# ID: 772bd5da-7fcf-4aa1-a23c-3d5889d0c149
+def sha256_file(path: Path) -> str:
+    """Pure helper for file hashing."""
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+# ID: 377f784e-516c-404b-8b36-ccd4346d299f
+def build_signature_from_ast(node: ast.AST) -> str:
+    """Pure helper for AST signature extraction."""
+    if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        return ""
+    args = [a.arg for a in node.args.args]
+    if node.args.vararg:
+        args.append("*" + node.args.vararg.arg)
+    for a in node.args.kwonlyargs:
+        args.append(a.arg + "=")
+    if node.args.kwarg:
+        args.append("**" + node.args.kwarg.arg)
+    return f"({', '.join(args)})"
+
+
+# ---------------------------
+# Governed Export Logic
+# ---------------------------
+
+
+# ID: 6c005976-a799-446d-aea4-2d04782c6b76
+class ContextExporter:
+    """Orchestrates the system snapshot using governed services."""
+
+    def __init__(self, context: CoreContext, output_base: Path | None = None):
+        self.repo_root = context.git_service.repo_path
+        self._context = context
+        self.output_base = output_base or (self.repo_root / "var" / "exports")
+        self.timestamp = now_iso().replace(":", "-").split(".")[0]
+        self.export_rel_dir = f"var/exports/core_export_{self.timestamp}"
+
+        # Mutation surface
+        self.fh = FileHandler(str(self.repo_root))
+        self.git = GitService(self.repo_root)
+
+    # ID: 2f5bda9b-4da0-486d-8748-c2c0a75a42dc
+    async def run(self) -> str:
+        """Execute the full export pipeline."""
+        logger.info("🚀 Starting CORE Context Export...")
+
+        # Ensure export directory
+        self.fh.ensure_dir(self.export_rel_dir)
+
+        # 1. Body (src) and Mind (.intent) Bundling
+        self._bundle_directories()
+
+        # 2. Symbol Analysis
+        await self._generate_symbol_index()
+
+        # 3. Database Metadata (State)
+        await self._export_db_schema()
+
+        # 4. Vector Metadata (Memory)
+        await self._export_qdrant_metadata()
+
+        # 5. Runtime & Manifest
+        await self._finalize_manifest()
+
+        logger.info("✅ Export complete: %s", self.export_rel_dir)
+        return self.export_rel_dir
+
+    def _bundle_directories(self):
+        """Create .tar.gz archives of key directories via FileHandler."""
+        logger.info("📦 Bundling src/ and .intent/...")
+
+        for folder in ["src", ".intent"]:
+            out_name = f"{folder.replace('.', '')}.tar.gz"
+            rel_out_path = f"{self.export_rel_dir}/{out_name}"
+
+            buffer = io.BytesIO()
+            with tarfile.open(fileobj=buffer, mode="w:gz") as tar:
+                src_path = self.repo_root / folder
+                if src_path.exists():
+                    tar.add(src_path, arcname=folder)
+
+            # Persist the archive via the approved mutation surface
+            self.fh.write_runtime_bytes(rel_out_path, buffer.getvalue())
+            logger.debug("   -> Governed Archive Created: %s", rel_out_path)
+
+    async def _generate_symbol_index(self):
+        """Scan Python symbols and write index via FileHandler."""
+        logger.info("🔍 Scanning Python symbols...")
+        symbols = []
+        src_root = self.repo_root / "src"
+
+        for py in src_root.rglob("*.py"):
+            rel_mod = str(py.relative_to(src_root)).replace("/", ".")[:-3]
+            try:
+                txt = py.read_text(encoding="utf-8")
+                tree = ast.parse(txt)
+                for node in tree.body:
+                    if isinstance(node, ast.ClassDef):
+                        symbols.append(
+                            Symbol(
+                                rel_mod,
+                                "class",
+                                node.name,
+                                node.lineno,
+                                "(...)",
+                                ast.get_docstring(node),
+                            )
+                        )
+                    elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        if not node.name.startswith("_"):
+                            sig = build_signature_from_ast(node)
+                            symbols.append(
+                                Symbol(
+                                    rel_mod,
+                                    "function",
+                                    node.name,
+                                    node.lineno,
+                                    sig,
+                                    ast.get_docstring(node),
+                                )
+                            )
+            except Exception:
+                continue
+
+        index_data = {
+            "generated_at": now_iso(),
+            "symbols": [dataclasses.asdict(s) for s in symbols],
+        }
+        self.fh.write_runtime_json(
+            f"{self.export_rel_dir}/symbol_index.json", index_data
+        )
+
+    async def _export_db_schema(self):
+        """Capture DB schema using subprocess, persisted via FileHandler."""
+        logger.info("🗄️ Capturing Database Schema...")
+        db_url = self._context.settings.DATABASE_URL
+
+        try:
+            # Note: requires pg_dump installed on host
+            proc = await asyncio.create_subprocess_exec(
+                "pg_dump",
+                "--schema-only",
+                "--no-owner",
+                db_url,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, _ = await proc.communicate()
+            if stdout:
+                self.fh.write_runtime_text(
+                    f"{self.export_rel_dir}/db_schema.sql", stdout.decode()
+                )
+        except Exception as e:
+            logger.warning("Could not export DB schema: %s", e)
+
+    async def _export_qdrant_metadata(self):
+        """Fetch Qdrant collection info via HTTP."""
+        logger.info("🧠 Capturing Qdrant Metadata...")
+        q_url = self._context.settings.QDRANT_URL.rstrip("/")
+        q_col = self._context.settings.QDRANT_COLLECTION_NAME
+
+        try:
+            # Use urllib for standard-lib compliance in scripts
+            url = f"{q_url}/collections/{q_col}"
+            req = urllib.request.Request(url, headers={"Accept": "application/json"})
+            with urllib.request.urlopen(
+                req, timeout=_CFG.context_export_http_timeout_sec
+            ) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+                self.fh.write_runtime_json(
+                    f"{self.export_rel_dir}/qdrant_info.json", data
+                )
+        except Exception as e:
+            logger.warning("Could not export Qdrant metadata: %s", e)
+
+    async def _finalize_manifest(self):
+        """Create the top-level manifest and checksums."""
+        logger.info("📄 Finalizing Export Manifest...")
+
+        manifest = {
+            "export_id": f"core_export_{self.timestamp}",
+            "generated_at": now_iso(),
+            "core_version": "1.0.0",
+            "git_info": {
+                "commit": (
+                    self.git.get_current_commit() if self.git.is_git_repo() else "none"
+                ),
+                "branch": "unknown",
+            },
+            "environment": self._context.settings.CORE_ENV,
+            "checksums": {},
+        }
+
+        # Calculate checksums for the bundles we created
+        export_path = self.repo_root / self.export_rel_dir
+        for bundle in export_path.glob("*.tar.gz"):
+            manifest["checksums"][bundle.name] = sha256_file(bundle)
+
+        self.fh.write_runtime_json(
+            f"{self.export_rel_dir}/core_context_manifest.json", manifest
+        )
+
+
+# ---------------------------
+# CLI Entrypoint
+# ---------------------------
+
+
+# ID: a13aecdf-8b7f-4649-bcd7-e42aab66b0bc
+async def main():
+    from body.infrastructure.bootstrap import create_core_context
+    from body.services.service_registry import service_registry
+
+    context = create_core_context(service_registry)
+    exporter = ContextExporter(context=context)
+    await exporter.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())