bone-agent 1.4.0 → 2.0.1

package/src/core/memory.py

@@ -1,145 +0,0 @@
-"""Multi-layer memory system for the agent.
-
-Two-layer persistent memory:
-- User memory (global): ~/.bone/user_memory.md
-- Project memory (per-repo): {repo_root}/.bone/agents.md
-
-Memory files are read-only during conversations — loaded into the system prompt
-for context but never written inline. All writes happen through the dream cron job,
-which consolidates user messages into focused memories nightly.
-"""
-
-import logging
-from pathlib import Path
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-# Capacity constants (prompt-enforced, no code enforcement)
-CHAR_LIMIT = 1500  # suggested chars per layer (~500 tokens)
-
-
-class MemoryManager:
-    """Manages two-layer memory: user-level (global) and project-level (per-repo).
-
-    Uses a lazy singleton pattern — first call with repo_root bootstraps the
-    instance, subsequent calls reuse it. Call reset() when switching repos.
-    """
-
-    _instance: Optional["MemoryManager"] = None
-
-    def __init__(self, repo_root: Path):
-        self.repo_root = repo_root
-        self.user_memory_path = Path.home() / ".bone" / "user_memory.md"
-        self.project_memory_path = repo_root / ".bone" / "agents.md"
-
-    @classmethod
-    def get_instance(cls, repo_root: Path = None) -> Optional["MemoryManager"]:
-        """Lazy singleton. First call sets repo_root, subsequent calls reuse instance.
-
-        Args:
-            repo_root: Path to repository root. Required on first call,
-                       ignored on subsequent calls (until reset()).
-
-        Returns:
-            MemoryManager instance, or None if no repo_root provided and
-            no instance has been initialized yet.
-        """
-        if cls._instance is not None:
-            return cls._instance
-        if repo_root is None:
-            return None
-        cls._instance = cls(repo_root)
-        return cls._instance
-
-    @classmethod
-    def reset(cls) -> None:
-        """Clear singleton. Called when switching repos via /cd."""
-        cls._instance = None
-
-    def ensure_exists(self) -> None:
-        """Create user-level directory and memory file only.
-
-        Project-level .bone/agents.md is created lazily on first write,
-        not at startup. This prevents creating .bone/ directories in
-        non-project locations (e.g. when running from ~/.bone/ itself).
-        """
-        self._ensure_dir_and_file(
-            self.user_memory_path,
-            "# User Memory\n\n",
-        )
-        # Add .bone/ to .gitignore if repo_root has a git repo
-        self._ensure_gitignore()
-
-    def load_user_memory(self) -> str:
-        """Read and return user memory file content. Returns empty string if missing."""
-        return self._read_file(self.user_memory_path)
-
-    def load_project_memory(self) -> str:
-        """Read and return project memory file content. Returns empty string if missing."""
-        return self._read_file(self.project_memory_path)
-
-    def get_user_usage(self) -> dict:
-        """Return {chars_used, chars_limit} for user memory."""
-        content = self.load_user_memory()
-        return {"chars_used": len(content), "chars_limit": CHAR_LIMIT}
-
-    def get_project_usage(self) -> dict:
-        """Return {chars_used, chars_limit} for project memory."""
-        content = self.load_project_memory()
-        return {"chars_used": len(content), "chars_limit": CHAR_LIMIT}
-
-    # ---- Private helpers ----
-
-    @staticmethod
-    def _has_entries(content: str) -> bool:
-        """Check if memory file has entries beyond just the header.
-
-        A file with only "# User Memory\\n\\n" is considered empty.
-        """
-        stripped = content.strip()
-        # Remove the H1 header line and blank lines
-        for line in stripped.split("\n"):
-            line = line.strip()
-            if not line or line.startswith("#"):
-                continue
-            # Found a non-header, non-blank line — has entries
-            return True
-        return False
-
-    @staticmethod
-    def _ensure_dir_and_file(path: Path, default_content: str) -> None:
-        """Create parent directory and file with default content if missing."""
-        try:
-            path.parent.mkdir(parents=True, exist_ok=True)
-            if not path.exists():
-                path.write_text(default_content, encoding="utf-8")
-                logger.debug("Created memory file: %s", path)
-        except Exception as e:
-            logger.warning("Failed to create memory file %s: %s", path, e)
-
-    @staticmethod
-    def _read_file(path: Path) -> str:
-        """Read file content, return empty string on any error."""
-        try:
-            if path.exists():
-                return path.read_text(encoding="utf-8")
-        except Exception as e:
-            logger.warning("Failed to read memory file %s: %s", path, e)
-        return ""
-
-    def _ensure_gitignore(self) -> None:
-        """Add .bone/ to .gitignore if not already present."""
-        gitignore = self.repo_root / ".gitignore"
-        if not self.repo_root.is_dir() or not (self.repo_root / ".git").is_dir():
-            return  # Not a git repo
-        try:
-            if not gitignore.exists():
-                gitignore.write_text(".bone/\n", encoding="utf-8")
-                return
-            content = gitignore.read_text(encoding="utf-8")
-            if ".bone" not in content:
-                with open(gitignore, "a", encoding="utf-8") as f:
-                    f.write("\n.bone/\n")
-        except Exception as e:
-            logger.warning("Failed to update .gitignore: %s", e)

package/src/core/metadata.py

@@ -1,75 +0,0 @@
-"""AI-powered metadata generation for skills and plugins.
-
-Generates description and tags from content when not provided manually.
-Shared between skill frontmatter and plugin registration.
-"""
-
-import json
-import logging
-import re
-
-logger = logging.getLogger(__name__)
-
-_SYSTEM_PROMPT = """\
-You generate concise metadata for code tools and prompts.
-
-Given the content below, return a JSON object with exactly two fields:
-- "description": a one-sentence summary (max 120 chars) of what this does
-- "tags": a list of 3-7 lowercase single-word tags for discovery
-
-Return ONLY the JSON object, no other text."""
-
-_MAX_CONTENT_CHARS = 3000
-
-
-def generate_metadata(content: str, name: str = "") -> dict:
-    """Generate description and tags from content using the LLM.
-
-    Args:
-        content: The skill prompt or plugin source to describe.
-        name: Optional name for context.
-
-    Returns:
-        Dict with 'description' (str) and 'tags' (list[str]).
-        Returns defaults on failure.
-    """
-    truncated = content[:_MAX_CONTENT_CHARS]
-    if len(content) > _MAX_CONTENT_CHARS:
-        truncated += "\n..."
-
-    user_msg = f"Name: {name}\n\n{truncated}" if name else truncated
-
-    try:
-        from llm.client import LLMClient
-
-        client = LLMClient()
-        response = client.chat_completion(
-            messages=[
-                {"role": "system", "content": _SYSTEM_PROMPT},
-                {"role": "user", "content": user_msg},
-            ],
-            stream=False,
-            tools=None,
-        )
-        raw = response["choices"][0]["message"]["content"].strip()
-        # Strip markdown code fences if present
-        raw = re.sub(r"^```(?:json)?\s*\n?", "", raw)
-        raw = re.sub(r"\n?```\s*$", "", raw)
-        parsed = json.loads(raw)
-
-        description = str(parsed.get("description", ""))[:120]
-        tags = [str(t).lower() for t in parsed.get("tags", []) if t]
-
-        return {"description": description, "tags": tags}
-
-    except Exception:
-        logger.debug("Metadata generation failed for '%s'", name, exc_info=True)
-        return _fallback_metadata(content, name)
-
-
-def _fallback_metadata(content: str, name: str) -> dict:
-    """Simple heuristic metadata when LLM is unavailable."""
-    # Use first line or first ~100 chars as description
-    first_line = content.strip().split("\n", 1)[0].strip()
-    desc = first_line[:120] if first_line else name
-    return {"description": desc, "tags": [name] if name else []}

package/src/core/retry.py

@@ -1,71 +0,0 @@
-"""Retry logic for LLM connection and timeout errors."""
-
-import time
-
-from exceptions import LLMResponseError
-
-# Timeout retry constants
-RETRY_MAX_ATTEMPTS = 3
-RETRY_DELAYS = (2, 4)  # exponential backoff per attempt
-RETRYABLE_STATUS_CODES = {429, 502, 503, 504}
-RETRYABLE_ERROR_KEYWORDS = (
-    "timeout", "timed out", "connectionerror", "connection refused",
-    "connection reset", "connection aborted", "name or service not known",
-    "network unreachable", "no route to host", "eof occurred",
-)
-NON_RETRYABLE_STATUS_CODES = {400, 401, 403, 405, 422}
-
-
-def is_retryable_error(error):
-    """Check if an LLMConnectionError is retryable.
-
-    Retryable conditions:
-    - Timeout or connection-level errors (network unreachable, DNS failure, etc.)
-    - HTTP 429 (rate limited), 502, 503, 504 (server errors)
-
-    Non-retryable conditions:
-    - HTTP 400, 401, 403, 405, 422 (client/auth errors)
-    - LLMResponseError (malformed response data)
-
-    Args:
-        error: Exception instance (typically LLMConnectionError)
-
-    Returns:
-        bool: True if the error is retryable
-    """
-    # Never retry response parsing errors
-    if isinstance(error, LLMResponseError):
-        return False
-
-    # Check HTTP status code first (most reliable signal)
-    details = getattr(error, 'details', {}) or {}
-    status_code = details.get("status_code")
-    if status_code is not None:
-        if status_code in NON_RETRYABLE_STATUS_CODES:
-            return False
-        if status_code in RETRYABLE_STATUS_CODES:
-            return True
-
-    # For network-level errors, check the original error message
-    original_error = details.get("original_error", "")
-    original_lower = original_error.lower()
-    return any(keyword in original_lower for keyword in RETRYABLE_ERROR_KEYWORDS)
-
-
-def wait_with_cancel_message(console, delay_seconds):
-    """Wait briefly before retrying, showing a dim status line.
-
-    Args:
-        console: Rich console for output
-        delay_seconds: Seconds to wait
-
-    Returns:
-        bool: True if wait completed, False if interrupted by KeyboardInterrupt
-    """
-    console.print(f"[dim]Connection issue, retrying in {delay_seconds}s... (Ctrl+C to cancel)[/dim]")
-    try:
-        time.sleep(delay_seconds)
-    except KeyboardInterrupt:
-        console.print("[dim]Retry cancelled.[/dim]")
-        return False
-    return True