bone-agent 1.3.2 → 1.4.0

package/src/core/cron.py

@@ -273,6 +273,41 @@ def _write_job_log(job: CronJob, output: str, error: bool):
         logger.error("Failed to write cron log: %s", e)
 
 
+# ── Dream job (auto-seeded) ─────────────────────────────────────────────
+
+DREAM_JOB_ID = "dream"
+DREAM_JOB_SCHEDULE = "daily at 4am"
+
+
+def ensure_dream_job(config: CronConfig) -> None:
+    """Sync the dream memory job with the DREAM_SETTINGS.enabled config.
+
+    - Enabled and missing  → seed the job
+    - Enabled and present  → no-op
+    - Disabled and present → remove the job
+    - Disabled and missing → no-op
+    """
+    from utils.settings import dream_settings
+    from llm.config import MEMORY_SETTINGS
+
+    if dream_settings.enabled and MEMORY_SETTINGS.get("enabled", True):
+        if DREAM_JOB_ID in config.jobs:
+            return
+        job = CronJob(
+            id=DREAM_JOB_ID,
+            schedule=DREAM_JOB_SCHEDULE,
+            command="Run the dream memory consolidation process. Read yesterday's user messages from ~/.bone/conversations/, analyze them for preferences and patterns, and consolidate into memory files. Then clean up JSONL files older than 7 days.",
+            enabled=True,
+            description="Dream memory consolidation — scans user messages and updates memories",
+        )
+        config.add_job(job)
+        logger.info("Seeded dream memory cron job (daily at 4am)")
+    else:
+        if DREAM_JOB_ID in config.jobs:
+            config.remove_job(DREAM_JOB_ID)
+            logger.info("Removed dream memory cron job (disabled in config)")
+
+
 def run_single_job(job: CronJob, console=None, interactive=False) -> None:
     """Execute a single cron job without requiring a CronScheduler instance.
 
@@ -309,22 +344,35 @@ def run_single_job(job: CronJob, console=None, interactive=False) -> None:
         from core.chat_manager import ChatManager
         from core.agentic import AgenticOrchestrator
         from utils.paths import RG_EXE_PATH
-        from tools.loader import load_all_tools
         from llm.config import TOOLS_ENABLED
 
         if not TOOLS_ENABLED:
             raise RuntimeError("Cron requires tools to be enabled")
 
-        # Ensure tools are loaded
-        load_all_tools()
-
         # Fresh ChatManager for this job
         chat_manager = ChatManager()
 
-        # Build the prompt — inject context about cron execution
+        # Dream job: auto-approve edits and run cleanup before agent starts
+        if job.id == DREAM_JOB_ID:
+            chat_manager.approve_mode = "accept_edits"
+            from utils.user_message_logger import UserMessageLogger
+            removed = UserMessageLogger.cleanup_old_files()
+            if removed:
+                logger.info("Dream job: removed %d old JSONL files", removed)
+
+        # Build the prompt — load dream.md for dream job, else use command field
+        if job.id == DREAM_JOB_ID:
+            dream_prompt_path = Path(__file__).resolve().parents[2] / "prompts" / "main" / "dream.md"
+            if dream_prompt_path.is_file():
+                command_text = dream_prompt_path.read_text(encoding="utf-8").strip()
+            else:
+                command_text = job.command
+        else:
+            command_text = job.command
+
         prompt = (
             f"[Cron job: {job.id}]\n"
-            f"{job.command}"
+            f"{command_text}"
         )
 
         repo_root = Path.cwd().resolve()
@@ -372,6 +420,9 @@ class CronScheduler:
         self._lock = threading.Lock()
         self._running = False
 
+        # Auto-seed the dream memory job if it doesn't exist
+        ensure_dream_job(self.config)
+
     def start(self):
         """Start the cron scheduler background thread."""
         enabled_jobs = [j for j in self.config.jobs.values() if j.enabled]

package/src/core/memory.py

@@ -4,8 +4,9 @@ Two-layer persistent memory:
 - User memory (global): ~/.bone/user_memory.md
 - Project memory (per-repo): {repo_root}/.bone/agents.md
 
-The agent writes to these files via edit_file (auto-approved, fire-and-forget).
-Memory content is injected into the system prompt on every conversation start.
+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
@@ -16,8 +17,6 @@ logger = logging.getLogger(__name__)
 
 # Capacity constants (prompt-enforced, no code enforcement)
 CHAR_LIMIT = 1500  # suggested chars per layer (~500 tokens)
-SECTION_LIMIT = 8   # suggested max sections per layer
-ENTRY_LIMIT = 20    # suggested max entries per section
 
 
 class MemoryManager:
@@ -80,17 +79,6 @@ class MemoryManager:
         """Read and return project memory file content. Returns empty string if missing."""
         return self._read_file(self.project_memory_path)
 
-    def load_all(self) -> str:
-        """Load both layers, combined for prompt injection."""
-        parts = []
-        user = self.load_user_memory()
-        project = self.load_project_memory()
-        if user.strip():
-            parts.append(user.strip())
-        if project.strip():
-            parts.append(project.strip())
-        return "\n\n".join(parts)
-
     def get_user_usage(self) -> dict:
         """Return {chars_used, chars_limit} for user memory."""
         content = self.load_user_memory()
@@ -101,81 +89,6 @@ class MemoryManager:
         content = self.load_project_memory()
         return {"chars_used": len(content), "chars_limit": CHAR_LIMIT}
 
-    def get_prompt_section(self) -> str:
-        """Build the full memory system prompt section.
-
-        Includes:
-        - Guidelines text with resolved file paths
-        - Capacity headers and memory content (if files have entries beyond headers)
-
-        Returns:
-            Complete prompt section string. Includes guidelines even when
-            memory files are empty (just headers). Returns guidelines with
-            placeholder paths if no MemoryManager instance exists.
-        """
-        user_path = str(self.user_memory_path)
-        project_path = str(self.project_memory_path)
-
-        lines = [
-            "## Memory System",
-            "",
-            "You have a two-layer memory system that persists across conversations:",
-            f"- User memory (global): {user_path} — preferences, identity, work patterns",
-            f"- Project memory (per-repo): {project_path} — context, conventions, decisions, current work",
-            "",
-            "Both memory layers are loaded into this prompt at conversation start. "
-            "You can already see all memories below.",
-            "",
-            "To save information, use `edit_file` to write directly to the memory files. "
-            "These edits are auto-approved and run silently.",
-            "Add a timestamp in parentheses: `*(YYYY-MM-DD)*`",
-            "",
-            "### Save these (proactively):",
-            "- User preferences: \"I prefer TypeScript over JavaScript\" → user memory",
-            "- Environment facts: \"This project uses Python 3.11 with pytest\" → project memory",
-            "- Corrections: \"Don't use sudo for docker, user is in docker group\" → project memory",
-            "- Conventions: \"Project uses tabs, 120-char line width\" → project memory",
-            "- Completed work: \"Migrated database schema on 2026-04-20\" → project memory",
-            "- Explicit requests: \"Remember that my API key rotation happens monthly\" → user memory",
-            "",
-            "### Skip these:",
-            "- Trivial/obvious info: \"User asked about Python\" — too vague to be useful",
-            "- Easily re-discovered facts: \"Python 3.12 supports f-string nesting\" — can web search this",
-            "- Raw data dumps: Large code blocks, log files, data tables — too big for memory",
-            "- Session-specific ephemera: Temporary file paths, one-off debugging context",
-            "- Information already in agents.md or other context files",
-            "",
-            "Keep memories concise and information-dense. Use the section that best fits the information.",
-            "To update a memory, edit the entry in place with a new timestamp.",
-            "To remove a memory, delete the line.",
-            f"Stay under {CHAR_LIMIT} chars per file (~500 tokens). "
-            f"When above 80% ({int(CHAR_LIMIT * 0.8)} chars), consolidate older entries before adding new ones.",
-        ]
-
-        # Add capacity headers and memory content if files have real content
-        user_content = self.load_user_memory()
-        user_usage = self.get_user_usage()
-        # Only show block if file has more than just the header
-        if self._has_entries(user_content):
-            pct = user_usage["chars_used"] * 100 // user_usage["chars_limit"]
-            lines.extend([
-                "",
-                f"USER MEMORY [{pct}% — {user_usage['chars_used']}/{user_usage['chars_limit']} chars]",
-                user_content.strip(),
-            ])
-
-        project_content = self.load_project_memory()
-        project_usage = self.get_project_usage()
-        if self._has_entries(project_content):
-            pct = project_usage["chars_used"] * 100 // project_usage["chars_limit"]
-            lines.extend([
-                "",
-                f"PROJECT MEMORY [{pct}% — {project_usage['chars_used']}/{project_usage['chars_limit']} chars]",
-                project_content.strip(),
-            ])
-
-        return "\n".join(lines)
-
     # ---- Private helpers ----
 
     @staticmethod

package/src/core/metadata.py

@@ -0,0 +1,75 @@
+"""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 []}