code-muse 0.0.1__py3-none-any.whl

code_muse/plugins/autonomous_memory/register_callbacks.py

@@ -0,0 +1,268 @@
+"""Autonomous Memory Pipeline — callback registrations.
+
+Wires the memory pipeline into the Fast Puppy runtime:
+- ``startup``: log memory status on boot
+- ``get_model_system_prompt``: inject memory into system prompts
+- ``custom_command`` / ``custom_command_help``: ``/memory`` slash command
+"""
+
+import logging
+from datetime import UTC
+from typing import Any
+
+from code_muse.callbacks import register_callback
+from code_muse.messaging import emit_error, emit_success, emit_warning
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Startup
+# ---------------------------------------------------------------------------
+
+
+def _setup_cython_hooks() -> None:
+    """Enable pyximport so .pyx modules compile on-the-fly."""
+    try:
+        import pyximport
+
+        pyximport.install(language_level=3, build_in_temp=True, inplace=True)
+        import code_muse
+
+        if code_muse.CYTHON_ENABLED:
+            emit_success(
+                f"✅ Cython enabled — {code_muse.PYX_MODULE_COUNT} modules compiled"
+            )
+        else:
+            emit_warning("⚠️ Cython not available — running in pure Python mode")
+    except Exception:
+        emit_warning("⚠️ Cython not available — running in pure Python mode")
+
+
+def _on_startup() -> None:
+    """Attempt to load memory injection (non-blocking)."""
+    try:
+        from .memory_injection import load_memory_injection
+
+        memory = load_memory_injection()
+        if memory:
+            logger.info("Memory injection available on startup")
+        else:
+            logger.debug("No fresh memory injection found")
+    except Exception as exc:
+        logger.warning(f"Memory startup check failed: {exc}")
+
+
+# ---------------------------------------------------------------------------
+# Startup
+# ---------------------------------------------------------------------------
+
+
+def _inject_memory_into_prompt(
+    model_name: str, default_system_prompt: str, user_prompt: str
+) -> dict[str, Any | None]:
+    """Callback to inject memory into system prompt.
+
+    Returns ``None`` when no memory is available so the prompt is unchanged.
+    Returns ``handled: False`` so other prompt-augmenting callbacks can
+    also run (e.g. the agent_skills plugin).
+    """
+    try:
+        from .memory_injection import load_memory_injection
+
+        memory_text = load_memory_injection()
+        if not memory_text:
+            return None
+
+        enhanced = f"{default_system_prompt}\n\n## Memory Guidance\n\n"
+        enhanced += (
+            "The following is accumulated project knowledge from past sessions.\n"
+            "Treat it as heuristic context, not authoritative fact. Always prefer\n"
+            "current repo evidence over conflicting memory. Cite the memory path\n"
+            "(MEMORY.md) when you use remembered information.\n\n"
+        )
+        enhanced += memory_text
+
+        return {
+            "instructions": enhanced,
+            "user_prompt": user_prompt,
+            "handled": False,
+        }
+    except Exception as exc:
+        logger.warning(f"Memory prompt injection failed: {exc}")
+        return None
+
+
+# ---------------------------------------------------------------------------
+# /memory slash command
+# ---------------------------------------------------------------------------
+
+
+def _memory_command_help() -> list[tuple[str, str]]:
+    return [
+        ("memory", "Show memory status"),
+        ("memory extract", "Trigger extraction now"),
+        ("memory forget", "Clear all memory files"),
+    ]
+
+
+def _handle_memory_command(command: str, name: str) -> bool | str | None:
+    """Handle ``/memory`` and its subcommands."""
+    if name != "memory":
+        return None
+
+    parts = command.strip().split()
+    subcommand = parts[1] if len(parts) > 1 else ""
+
+    if subcommand in ("", "status"):
+        return _memory_status()
+
+    if subcommand == "extract":
+        return _memory_extract()
+
+    if subcommand == "forget":
+        return _memory_forget()
+
+    emit_error(f"Unknown /memory subcommand: {subcommand}")
+    return True
+
+
+def _memory_status() -> str:
+    """Display current memory status."""
+    try:
+        from .session_scanner import (
+            get_memory_dir,
+            get_project_hash,
+            get_sessions_dir,
+            scan_eligible_sessions,
+        )
+
+        sessions_dir = get_sessions_dir()
+        state_file = sessions_dir / ".memory_state.json"
+        eligible = scan_eligible_sessions(sessions_dir, state_file)
+
+        project_hash = get_project_hash()
+        memory_dir = get_memory_dir(project_hash)
+        memory_path = memory_dir / "MEMORY.md"
+        summary_path = memory_dir / "memory_summary.md"
+
+        lines: list[str] = ["=== Memory Status ==="]
+        lines.append(f"Eligible sessions: {len(eligible)}")
+        lines.append(f"Memory dir: {memory_dir}")
+        lines.append(f"MEMORY.md exists: {memory_path.exists()}")
+        lines.append(f"memory_summary.md exists: {summary_path.exists()}")
+
+        if summary_path.exists():
+            mtime = summary_path.stat().st_mtime
+            from datetime import datetime
+
+            dt = datetime.fromtimestamp(mtime, tz=UTC)
+            lines.append(f"Last extraction: {dt.isoformat()}")
+
+        return "\n".join(lines)
+    except Exception as exc:
+        logger.error(f"Memory status failed: {exc}")
+        return f"Memory status error: {exc}"
+
+
+def _memory_extract() -> str:
+    """Run the full extraction pipeline immediately."""
+    try:
+        from .consolidation import consolidate_memories, write_memory_files
+        from .extraction import extract_session_knowledge
+        from .lease_lock import acquire_memory_lease, release_lease
+        from .secret_scanner import scan_for_secrets
+        from .session_scanner import (
+            get_memory_dir,
+            get_project_hash,
+            get_sessions_dir,
+            mark_session_processed,
+            scan_eligible_sessions,
+        )
+
+        sessions_dir = get_sessions_dir()
+        state_file = sessions_dir / ".memory_state.json"
+        eligible = scan_eligible_sessions(sessions_dir, state_file)
+
+        if not eligible:
+            return "No eligible sessions found for extraction."
+
+        project_hash = get_project_hash()
+        memory_dir = get_memory_dir(project_hash)
+
+        lease = acquire_memory_lease(memory_dir)
+        if lease is None:
+            return "Memory pipeline is already running (lease held). Try again later."
+
+        try:
+            extractions = []
+            for info in eligible:
+                result = extract_session_knowledge(info.path)
+                if result:
+                    extractions.append(result)
+                    mark_session_processed(state_file, str(info.path))
+
+            if not extractions:
+                return "Extraction produced no results."
+
+            consolidated = consolidate_memories(extractions, sessions_dir)
+
+            # Safety scan before writing
+            secrets = scan_for_secrets(consolidated)
+            if secrets:
+                secret_names = ", ".join(sorted({s.pattern_name for s in secrets}))
+                logger.warning(
+                    f"Secrets detected in consolidated memory: {secret_names}"
+                )
+
+            memory_path, summary_path = write_memory_files(consolidated, memory_dir)
+            return (
+                f"Extraction complete: {len(extractions)} sessions, "
+                f"MEMORY.md → {memory_path}, summary → {summary_path}"
+            )
+        finally:
+            release_lease(lease)
+    except Exception as exc:
+        logger.error(f"Memory extraction failed: {exc}")
+        return f"Extraction error: {exc}"
+
+
+def _memory_forget() -> str:
+    """Remove all memory files for the current project."""
+    try:
+        from .session_scanner import get_memory_dir, get_project_hash
+
+        project_hash = get_project_hash()
+        memory_dir = get_memory_dir(project_hash)
+
+        if not memory_dir.exists():
+            return "No memory files to forget."
+
+        deleted: list[str] = []
+        for child in memory_dir.iterdir():
+            try:
+                if child.is_file():
+                    child.unlink()
+                    deleted.append(child.name)
+                elif child.is_dir():
+                    # Don't recursively delete; just report
+                    deleted.append(f"{child.name}/ (skipped)")
+            except OSError as exc:
+                logger.warning(f"Could not delete {child}: {exc}")
+
+        return f"Forgot memory files: {', '.join(deleted) or 'none'}"
+    except Exception as exc:
+        logger.error(f"Memory forget failed: {exc}")
+        return f"Forget error: {exc}"
+
+
+# ---------------------------------------------------------------------------
+# Register callbacks
+# ---------------------------------------------------------------------------
+
+register_callback("startup", _setup_cython_hooks)
+register_callback("startup", _on_startup)
+register_callback("get_model_system_prompt", _inject_memory_into_prompt)
+register_callback("custom_command_help", _memory_command_help)
+register_callback("custom_command", _handle_memory_command)
+
+logger.info("Autonomous Memory Pipeline plugin loaded")

code_muse/plugins/autonomous_memory/secret_scanner.py

@@ -0,0 +1,62 @@
+"""Secret scanner for the Autonomous Memory Pipeline.
+
+Detects common secret patterns in extracted memory text before it is
+written to disk, helping prevent accidental credential leakage.
+"""
+
+import logging
+import re
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+SCAN_PATTERNS: list[tuple[str, str]] = [
+    ("aws_access_key", r"AKIA[0-9A-Z]{16}"),
+    ("github_token", r"ghp_[0-9a-zA-Z]{36}"),
+    ("openai_api_key", r"sk-[0-9a-zA-Z]{48}"),
+    (
+        "private_key_header",
+        r"-----BEGIN (RSA|EC|OPENSSH|PGP) PRIVATE KEY-----",
+    ),
+    (
+        "jwt_token",
+        r"eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}",
+    ),
+    (
+        "generic_api_key",
+        r"(api[_-]?key|apikey|secret|token|password)\s*[:=]\s*['\"]?[A-Za-z0-9+/=]{20,}['\"]?",
+    ),
+]
+
+
+@dataclass
+class SecretMatch:
+    """A single secret pattern match."""
+
+    pattern_name: str
+    line_number: int
+    context: str
+
+
+def scan_for_secrets(text: str) -> list[SecretMatch]:
+    """Scan ``text`` for known secret patterns.
+
+    Returns a list of :class:`SecretMatch` objects with line numbers and
+    a short context snippet (first 40 characters of the match).
+    """
+    matches: list[SecretMatch] = []
+    lines = text.splitlines()
+
+    for pattern_name, pattern in SCAN_PATTERNS:
+        for line_idx, line in enumerate(lines, start=1):
+            for match in re.finditer(pattern, line, re.IGNORECASE):
+                context = match.group(0)[:40]
+                matches.append(
+                    SecretMatch(
+                        pattern_name=pattern_name,
+                        line_number=line_idx,
+                        context=context,
+                    )
+                )
+
+    return matches

code_muse/plugins/autonomous_memory/session_scanner.py

@@ -0,0 +1,163 @@
+"""Session scanner for the Autonomous Memory Pipeline.
+
+Discovers eligible past sessions based on message count, activity status,
+and idle time. Tracks processed sessions via a persistent state file.
+"""
+
+import hashlib
+import json
+import logging
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+IDLE_THRESHOLD_SECONDS = 10_800  # 3 hours
+ACTIVE_THRESHOLD_SECONDS = 1_800  # 30 minutes
+MIN_MESSAGE_COUNT = 10
+
+
+@dataclass
+class SessionInfo:
+    """Summary of a discovered session directory."""
+
+    path: Path
+    message_count: int
+    last_active: float
+    is_active: bool
+    processed: bool
+
+
+def _find_messages_file(session_dir: Path) -> Path | None:
+    """Locate the messages file (messages.json or any .jsonl) in a session dir."""
+    candidates = [
+        session_dir / "messages.json",
+        *session_dir.glob("*.jsonl"),
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def _count_user_messages(messages_path: Path) -> int:
+    """Count lines that appear to contain a user message."""
+    try:
+        with messages_path.open("r", encoding="utf-8") as fh:
+            return sum(
+                1 for line in fh if '"role": "user"' in line or '"role":"user"' in line
+            )
+    except Exception as exc:
+        logger.warning(f"Failed to count messages in {messages_path}: {exc}")
+        return 0
+
+
+def _read_state(state_file: Path) -> dict[str, Any]:
+    """Read the processed-sessions state file."""
+    if not state_file.exists():
+        return {"processed": []}
+    try:
+        with state_file.open("r", encoding="utf-8") as fh:
+            data = json.load(fh)
+            if isinstance(data, dict) and isinstance(data.get("processed"), list):
+                return data
+    except Exception as exc:
+        logger.warning(f"Corrupt state file {state_file}: {exc}")
+    return {"processed": []}
+
+
+def _write_state(state_file: Path, data: dict[str, Any]) -> None:
+    """Persist the processed-sessions state file."""
+    state_file.parent.mkdir(parents=True, exist_ok=True)
+    with state_file.open("w", encoding="utf-8") as fh:
+        json.dump(data, fh, indent=2)
+
+
+def scan_eligible_sessions(sessions_dir: Path, state_file: Path) -> list[SessionInfo]:
+    """Scan for sessions that are eligible for memory extraction.
+
+    Filters:
+      - message_count >= 10
+      - not currently active
+      - idle > 3 hours
+      - not already processed
+
+    Results are sorted by ``last_active`` descending (most recent first).
+    """
+    if not sessions_dir.exists():
+        return []
+
+    state = _read_state(state_file)
+    processed_paths: set[str] = set(state.get("processed", []))
+    now = time.time()
+    sessions: list[SessionInfo] = []
+
+    for entry in sessions_dir.iterdir():
+        if not entry.is_dir():
+            continue
+
+        messages_file = _find_messages_file(entry)
+        if messages_file is None:
+            continue
+
+        msg_count = _count_user_messages(messages_file)
+        last_active = messages_file.stat().st_mtime
+        idle_seconds = now - last_active
+
+        # Active = has a lock file OR recent mtime (< 30 min)
+        lock_file = entry / ".session_lock"
+        is_active = lock_file.exists() or idle_seconds < ACTIVE_THRESHOLD_SECONDS
+
+        session_path_str = str(entry)
+        processed = session_path_str in processed_paths
+
+        if msg_count < MIN_MESSAGE_COUNT:
+            continue
+        if is_active:
+            continue
+        if idle_seconds <= IDLE_THRESHOLD_SECONDS:
+            continue
+        if processed:
+            continue
+
+        sessions.append(
+            SessionInfo(
+                path=entry,
+                message_count=msg_count,
+                last_active=last_active,
+                is_active=is_active,
+                processed=processed,
+            )
+        )
+
+    sessions.sort(key=lambda s: s.last_active, reverse=True)
+    return sessions
+
+
+def mark_session_processed(state_file: Path, session_path: str) -> None:
+    """Record a session as processed so it won't be re-scanned."""
+    state = _read_state(state_file)
+    processed: list[str] = state.get("processed", [])
+    if session_path not in processed:
+        processed.append(session_path)
+        state["processed"] = processed
+        _write_state(state_file, state)
+
+
+def get_sessions_dir() -> Path:
+    """Return the global sessions storage directory."""
+    return Path.home() / ".muse" / "sessions"
+
+
+def get_memory_dir(project_hash: str) -> Path:
+    """Return the memory storage directory for a given project hash."""
+    return Path.home() / ".muse" / "memory" / project_hash
+
+
+def get_project_hash(cwd: str | None = None) -> str:
+    """Compute a 12-char project hash from the working directory."""
+    cwd = cwd or os.getcwd()
+    return hashlib.sha256(cwd.encode()).hexdigest()[:12]

code_muse/plugins/aws_bedrock/__init__.py

@@ -0,0 +1,14 @@
+"""AWS Bedrock Plugin for Muse.
+
+This plugin enables Muse to use Anthropic Claude models hosted on
+AWS Bedrock with standard AWS credential chain authentication (env vars,
+profiles, IAM roles, SSO).
+
+Supported models:
+- Claude Opus 4.7 (1M context)
+- Claude Opus 4.6 (1M context)
+- Claude Sonnet 4.6 (1M context)
+- Claude Haiku 4.5 (200K context)
+"""
+
+__version__ = "0.1.0"

code_muse/plugins/aws_bedrock/config.py

@@ -0,0 +1,99 @@
+"""Configuration constants for the AWS Bedrock plugin."""
+
+import functools
+import os
+from pathlib import Path
+
+from code_muse.config import DATA_DIR
+
+ENV_AWS_REGION = "AWS_REGION"
+ENV_AWS_PROFILE = "AWS_PROFILE"
+ENV_BEDROCK_REGION = "BEDROCK_REGION"
+
+DEFAULT_REGION = "us-east-1"
+
+
+@functools.lru_cache(maxsize=1)
+def _detect_region() -> str | None:
+    """Detect region from boto3 session or EC2 instance metadata.
+
+    Result is cached for the process lifetime: on non-EC2 hosts with no
+    AWS config, the IMDS path below incurs two 1-second timeouts, and
+    this function is called on every model instantiation.
+    """
+    try:
+        import boto3
+
+        region = boto3.Session().region_name
+        if region:
+            return region
+    except Exception:
+        pass
+
+    try:
+        import urllib.request
+
+        token_req = urllib.request.Request(
+            "http://169.254.169.254/latest/api/token",
+            method="PUT",
+            headers={"X-aws-ec2-metadata-token-ttl-seconds": "30"},
+        )
+        token = urllib.request.urlopen(token_req, timeout=1).read().decode()
+        region_req = urllib.request.Request(
+            "http://169.254.169.254/latest/meta-data/placement/region",
+            headers={"X-aws-ec2-metadata-token": token},
+        )
+        return urllib.request.urlopen(region_req, timeout=1).read().decode()
+    except Exception:
+        return None
+
+
+MODELS: list[dict] = [
+    {
+        "base_key": "bedrock-opus-4-7",
+        "model_id": "us.anthropic.claude-opus-4-7",
+        "context_length": 1000000,
+        "variants": ["default", "low", "medium", "high", "xhigh", "max"],
+    },
+    {
+        "base_key": "bedrock-opus-4-6",
+        "model_id": "us.anthropic.claude-opus-4-6-v1:0",
+        "context_length": 1000000,
+        "variants": ["default", "low", "medium", "high", "max"],
+    },
+    {
+        "base_key": "bedrock-sonnet-4-6",
+        "model_id": "us.anthropic.claude-sonnet-4-6-v1:0",
+        "context_length": 1000000,
+        "variants": ["default", "low", "medium", "high", "max"],
+    },
+    {
+        "base_key": "bedrock-haiku",
+        "model_id": "us.anthropic.claude-haiku-4-5-20251001-v1:0",
+        "context_length": 200000,
+        "variants": None,
+    },
+]
+
+
+def get_bedrock_region() -> str:
+    """Get the AWS region for Bedrock.
+
+    Precedence: BEDROCK_REGION > AWS_REGION > boto3 session > default.
+    """
+    return (
+        os.environ.get(ENV_BEDROCK_REGION)
+        or os.environ.get(ENV_AWS_REGION)
+        or _detect_region()
+        or DEFAULT_REGION
+    )
+
+
+def get_aws_profile() -> str | None:
+    """Get the AWS profile name from environment."""
+    return os.environ.get(ENV_AWS_PROFILE)
+
+
+def get_extra_models_path() -> Path:
+    """Get the path to the extra_models.json file."""
+    return Path(DATA_DIR) / "extra_models.json"