bone-agent 1.3.2 → 1.4.0

package/src/ui/displays.py

@@ -22,7 +22,7 @@ def show_provider_table(current_provider: str, console):
         else:
             status = "✅" if cfg.get("api_key") else "❌ (set API key)"
         active = " [green](active)[/green]" if provider == current_provider else ""
-        table.add_row(provider.capitalize(), status, f"{model[:40]}{active}")
+        table.add_row(config.get_provider_display_name(provider), status, f"{model[:40]}{active}")
 
     console.print(table)
 
@@ -66,10 +66,12 @@ def show_help_table(console):
     table.add_row("[bold #5F9EA0]/cd[/bold #5F9EA0] [path]", "Change working directory (no args to show current)")
     table.add_row("[bold #5F9EA0]/edit[/bold #5F9EA0], [bold #5F9EA0]/e[/bold #5F9EA0]", "Open editor for multi-line input")
     table.add_row("[bold #5F9EA0]/review[/bold #5F9EA0] [args], [bold #5F9EA0]/r[/bold #5F9EA0]", "Code review git changes (e.g. /review --staged, /review main..HEAD)")
+    table.add_row("[bold #5F9EA0]/skills[/bold #5F9EA0] [list|add|modify|remove|use]", "Manage reusable prompt skills")
     table.add_row("[bold #5F9EA0]/obsidian[/bold #5F9EA0] [set|enable|disable|status|init]", "Manage vault integration, scaffold project folders")
     table.add_row("[bold #5F9EA0]/tools[/bold #5F9EA0] [list|enable|disable|enable-group|disable-group]", "Toggle tools or groups (e.g. file_ops, task_mgmt)")
     table.add_row("[bold #5F9EA0]/setup[/bold #5F9EA0]", "Re-run the first-run setup wizard")
     table.add_row("[bold #5F9EA0]/cron[/bold #5F9EA0] [list|add|remove|enable|disable|run]", "Manage scheduled cron jobs")
+    table.add_row("[bold #5F9EA0]:[/bold #5F9EA0]<command>", "Run a shell command (e.g. :git status)")
 
 
     console.print(Panel(table, title="[bold #5F9EA0]Commands[/bold #5F9EA0]", border_style="grey23", padding=(0, 2)))
@@ -141,6 +143,30 @@ def show_cron_help_table(console):
     console.print("")
 
 
+def show_skills_help_table(console):
+    """Display skills command help table.
+
+    Args:
+        console: Rich Console instance for output.
+    """
+    console.print("")
+    table = Table(show_header=True, box=box.SIMPLE_HEAD)
+    table.add_column("Command", no_wrap=True)
+    table.add_column("Description")
+
+    table.add_row("[bold #5F9EA0]/skills list[/bold #5F9EA0]", "List skills")
+    table.add_row("[bold #5F9EA0]/skills add[/bold #5F9EA0] <name>", "Create a skill in your editor")
+    table.add_row("[bold #5F9EA0]/skills edit[/bold #5F9EA0] <name>", "Edit an existing skill")
+    table.add_row("[bold #5F9EA0]/skills modify[/bold #5F9EA0] <name> <prompt>", "Replace a skill")
+    table.add_row("[bold #5F9EA0]/skills show[/bold #5F9EA0] <name>", "Show a skill")
+    table.add_row("[bold #5F9EA0]/skills load[/bold #5F9EA0] <name>", "Load a skill into this chat")
+    table.add_row("[bold #5F9EA0]/skills remove[/bold #5F9EA0] <name>", "Delete a skill")
+    table.add_row("[bold #5F9EA0]/skills dir[/bold #5F9EA0]", "Show the skills directory")
+
+    console.print(Panel(table, title="[bold #5F9EA0]Skills[/bold #5F9EA0]", border_style="grey23", padding=(0, 2)))
+    console.print("")
+
+
 def show_config_overview(chat_manager, console, debug_mode_container, current_provider):
     """Display comprehensive configuration overview.
 

package/src/ui/main.py

@@ -35,7 +35,6 @@ from core.agentic import agentic_answer
 from utils.settings import MonokaiDarkBGStyle, left_align_headings
 from utils.paths import REPO_ROOT, RG_EXE_PATH
 from exceptions import BoneAgentError
-from tools.loader import load_all_tools
 
 # Console setup
 console = Console(theme=Theme({
@@ -382,9 +381,6 @@ def main():
     """Main interactive chat loop."""
 
     # Load all tools (built-in and user tools)
-    # This populates the ToolRegistry with all decorated tools
-    load_all_tools()
-
     # Check for config.yaml — run setup wizard on first run
     from ui.setup_wizard import is_first_run, run_wizard as _run_setup_wizard
 
@@ -507,6 +503,7 @@ def main():
                 thinking_indicator.start()
                 INPUT_BLOCKED['blocked'] = True
                 try:
+                    console.print("─" * console.width, style="rgb(30,30,30)")
                     console.print()  # Extra newline after user input to separate from LLM response
                     # Add user message
                     if TOOLS_ENABLED:

package/src/ui/tool_confirmation.py

@@ -1,6 +1,7 @@
 """Interactive tool confirmation panel with arrow key navigation."""
 
 import asyncio
+from html import escape
 from threading import Timer
 from typing import Optional, Tuple
 from prompt_toolkit import HTML
@@ -50,6 +51,16 @@ class ToolConfirmationPanel:
         # Use appropriate options based on tool type
         self._options = self.EDIT_OPTIONS if is_edit_tool else self.STANDARD_OPTIONS
 
+    def _append_field(self, lines: list[str], label: str, value: object, *, formatted: bool = False) -> None:
+        """Append a field to the panel, escaping untrusted values by default."""
+        value_text = str(value)
+        if not formatted:
+            value_text = escape(value_text)
+        value_lines = value_text.splitlines() or [""]
+        lines.append(f"<b>{escape(label)}:</b> {value_lines[0]}")
+        for continuation in value_lines[1:]:
+            lines.append(f"    {continuation}")
+
     def _get_display_text(self) -> HTML:
         """Get the formatted text to display.
 
@@ -66,14 +77,14 @@ class ToolConfirmationPanel:
 
             lines.append("<b>Selection Summary</b>")
             lines.append("")
-            lines.append(f"<b>Tool:</b> {self.tool_command}")
-            lines.append(f'<style fg="gray">  Selected: {str(selected_text)}</style>')
+            self._append_field(lines, "Tool", self.tool_command)
+            lines.append(f'<style fg="gray">  Selected: {escape(str(selected_text))}</style>')
             lines.append("")
         else:
             # Tool information
-            lines.append(f"<b>Tool:</b> {self.tool_command}")
+            self._append_field(lines, "Tool", self.tool_command)
             if self.reason:
-                lines.append(f"<b>Reason:</b> {self.reason}")
+                self._append_field(lines, "Reason", self.reason)
             lines.append("")
 
             # Render options
@@ -87,7 +98,7 @@ class ToolConfirmationPanel:
                     # Unselected option - dark grey
                     lines.append(f'<style fg="gray">  {text}</style>')
 
-            return HTML("\n".join(lines))
+        return HTML("\n".join(lines))
 
     def _exit_with_summary(self, event, result: str) -> None:
         """Show summary screen and exit application after delay.

package/src/utils/editor.py

@@ -1,6 +1,7 @@
 """External editor integration for bone-agent."""
 import os
 import platform
+import shlex
 import subprocess
 import tempfile
 import shutil
@@ -12,27 +13,30 @@ def get_editor() -> str:
     """Get editor command with OS-specific defaults.
 
     Priority:
-    1. EDITOR environment variable
-    2. OS defaults: notepad.exe (Windows) | nano/vi/vim (Unix)
+    1. Windows: notepad.exe
+    2. Linux: nvim, then EDITOR, then nano/vi/vim
+    3. Other Unix: EDITOR, then nano/vi/vim
 
     Returns:
         str: Editor command or path
     """
-    # 1. Check environment variable
+    system = platform.system()
+
+    if system == "Windows":
+        return "notepad.exe"
+
+    if system == "Linux" and shutil.which("nvim"):
+        return "nvim"
+
     editor = os.environ.get("EDITOR")
     if editor and editor.strip():
         return editor.strip()
 
-    # 2. OS-specific defaults
-    if platform.system() == "Windows":
-        return "notepad.exe"
-    else:
-        # Try to find common editors
-        for cmd in ["nvim", "nano", "vi", "vim"]:
-            if shutil.which(cmd):
-                return cmd
-        # Fallback to nano even if not found (will error later)
-        return "nano"
+    for cmd in ["nano", "vi", "vim"]:
+        if shutil.which(cmd):
+            return cmd
+
+    return "nano"
 
 
 def _create_temp_file() -> Tuple[Path, object]:
@@ -74,24 +78,38 @@ def _strip_comment_lines(content: str) -> str:
     return '\n'.join(lines).strip()
 
 
-def open_editor_for_input(console, debug_mode: bool = False) -> Tuple[bool, Optional[str]]:
-    """Open external editor and return user input.
+def _build_editor_command(editor_cmd: str, temp_path: Path) -> Tuple[bool, str | list[str]]:
+    """Build a subprocess command for launching the configured editor."""
+    use_shell = platform.system() == "Windows"
+    if use_shell:
+        return use_shell, f'{editor_cmd} "{temp_path}"'
 
-    Args:
-        console: Rich console for output
-        debug_mode: Whether to show debug information
+    try:
+        command_parts = shlex.split(editor_cmd)
+    except ValueError as e:
+        raise ValueError(f"Invalid EDITOR command: {e}") from e
 
-    Returns:
-        tuple: (success: bool, content: str or None)
-            - (True, content) if successful
-            - (False, None) if failed or cancelled
-    """
-    editor_cmd = get_editor()
+    if not command_parts:
+        raise FileNotFoundError(editor_cmd)
+
+    return use_shell, [*command_parts, str(temp_path)]
+
+
+def _open_editor_with_temp_file(
+    console,
+    editor_cmd: str,
+    debug_mode: bool = False,
+    initial_content: str = "",
+    post_process=None,
+) -> Tuple[bool, Optional[str]]:
+    """Open the configured editor for a temporary file and return the saved content."""
     temp_path = None
 
     try:
-        # Create temporary file
         temp_path, temp_fd = _create_temp_file()
+        if initial_content:
+            temp_fd.write(initial_content)
+            temp_fd.flush()
         temp_fd.close()
 
         if debug_mode:
@@ -101,24 +119,19 @@ def open_editor_for_input(console, debug_mode: bool = False) -> Tuple[bool, Opti
         console.print("[#5F9EA0]Opening editor...[/#5F9EA0]")
         console.print("[dim]Save and close the editor when done[/dim]")
 
-        # Launch editor and wait for it to close
-        # Use shell=True on Windows for notepad, False for better security on Unix
-        use_shell = platform.system() == "Windows"
-
+        use_shell, command = _build_editor_command(editor_cmd, temp_path)
         result = subprocess.run(
-            [editor_cmd, str(temp_path)],
+            command,
             shell=use_shell,
-            check=False  # Don't raise on non-zero exit
+            check=False,
         )
 
         if result.returncode != 0 and debug_mode:
             console.print(f"[yellow]Editor exited with code {result.returncode}[/yellow]")
 
-        # Read content from temp file
-        content = temp_path.read_text(encoding='utf-8')
-
-        # Strip comment lines
-        content = _strip_comment_lines(content)
+        content = temp_path.read_text(encoding="utf-8")
+        if post_process is not None:
+            content = post_process(content)
 
         if debug_mode:
             console.print(f"[dim]Read {len(content)} characters[/dim]")
@@ -145,14 +158,50 @@ def open_editor_for_input(console, debug_mode: bool = False) -> Tuple[bool, Opti
         return (False, None)
 
     finally:
-        # Cleanup temp file
         if temp_path and temp_path.exists():
             try:
                 temp_path.unlink()
                 if debug_mode:
-                    console.print(f"[dim]Cleaned up temp file[/dim]")
+                    console.print("[dim]Cleaned up temp file[/dim]")
             except Exception as e:
-                # Log but don't crash on cleanup failure
                 console.print(f"[yellow]Warning: Failed to delete temp file: {e}[/yellow]")
                 if debug_mode:
                     console.print(f"[dim]Temp file may remain at: {temp_path}[/dim]")
+
+
+def open_editor_for_input(console, debug_mode: bool = False) -> Tuple[bool, Optional[str]]:
+    """Open external editor and return user input.
+
+    Args:
+        console: Rich console for output
+        debug_mode: Whether to show debug information
+
+    Returns:
+        tuple: (success: bool, content: str or None)
+            - (True, content) if successful
+            - (False, None) if failed or cancelled
+    """
+    return _open_editor_with_temp_file(
+        console,
+        editor_cmd=get_editor(),
+        debug_mode=debug_mode,
+        post_process=_strip_comment_lines,
+    )
+
+
+def open_editor_for_content(
+    console,
+    initial_content: str = "",
+    debug_mode: bool = False,
+) -> Tuple[bool, Optional[str]]:
+    """Open external editor with initial content and return the saved file.
+
+    Unlike open_editor_for_input, this preserves markdown comment lines so it can
+    edit existing markdown files without dropping headings or notes.
+    """
+    return _open_editor_with_temp_file(
+        console,
+        editor_cmd=get_editor(),
+        debug_mode=debug_mode,
+        initial_content=initial_content or "",
+    )

package/src/utils/settings.py

@@ -28,10 +28,14 @@ def left_align_headings(text: str) -> str:
 @dataclass
 class ServerSettings:
     """Local llama-server configuration."""
-    ngl_layers: int = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("ngl_layers", 30))
+    ngl_layers: int = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("ngl_layers", 99))
     ctx_size: int = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("ctx_size", 8192))
     n_predict: int = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("n_predict", 8192))
     rope_scale: float = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("rope_scale", 1.0))
+    threads: int = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("threads", 4))
+    batch_size: int = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("batch_size", 2048))
+    ubatch_size: int = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("ubatch_size", 512))
+    flash_attn: bool = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("flash_attn", True))
     health_check_timeout_sec: int = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("health_check_timeout_sec", 120))
     health_check_interval_sec: float = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("health_check_interval_sec", 1.0))
 
@@ -47,6 +51,7 @@ class ToolSettings:
     max_shell_output_lines: int = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("max_shell_output_lines", 200))
     max_file_preview_lines: int = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("max_file_preview_lines", 200))
     disabled_tools: list = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("disabled_tools", []))
+    hidden_skills: list = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("hidden_skills", []))
 
 @dataclass
 class FileSettings:
@@ -76,11 +81,14 @@ class ToolCompactionSettings:
 @dataclass
 class SubAgentSettings:
     """Sub-agent token limits and behavior configuration."""
-    soft_limit_tokens: int = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("soft_limit_tokens", 300_000))
-    hard_limit_tokens: int = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("hard_limit_tokens", 500_000))
+    soft_limit_tokens: int = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("soft_limit_tokens", 100_000))
+    hard_limit_tokens: int = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("hard_limit_tokens", 150_000))
+    billed_warning_tokens: int = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("billed_warning_tokens", 200_000))
+    billed_hard_limit_tokens: int = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("billed_hard_limit_tokens", 500_000))
     enable_compaction: bool = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("enable_compaction", True))
     compact_trigger_tokens: int = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("compact_trigger_tokens", 50_000))
     allowed_tools: list = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("allowed_tools", ["rg", "read_file", "list_directory", "web_search"]))
+    allow_active_plugins: bool = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("allow_active_plugins", False))
     dump_context_on_hard_limit: bool = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("dump_context_on_hard_limit", True))
 
 
@@ -104,6 +112,18 @@ class ContextSettings:
             self.hard_limit_tokens = int(self.max_context_window * 0.9)
 
 
+@dataclass
+class PromptSettings:
+    """Prompt variant selection."""
+    variant: str = field(default_factory=lambda: _CONFIG.get("PROMPT_SETTINGS", {}).get("variant", "micro"))
+
+
+@dataclass
+class DreamSettings:
+    """Dream memory consolidation settings."""
+    enabled: bool = field(default_factory=lambda: _CONFIG.get("DREAM_SETTINGS", {}).get("enabled", True))
+
+
 @dataclass
 class ObsidianSettings:
     """Obsidian vault integration settings.
@@ -165,8 +185,9 @@ tool_settings = ToolSettings()
 file_settings = FileSettings()
 context_settings = ContextSettings()
 sub_agent_settings = SubAgentSettings()
+dream_settings = DreamSettings()
 obsidian_settings = ObsidianSettings()
-
+prompt_settings = PromptSettings()
 # Tool execution constants
 MAX_TOOL_CALLS = tool_settings.max_tool_calls
 MAX_COMMAND_OUTPUT_LINES = tool_settings.max_command_output_lines

package/src/utils/user_message_logger.py

@@ -0,0 +1,120 @@
+"""Lightweight user-message logger for the dream memory system.
+
+Appends one JSONL line per user message, one file per day per project.
+Always on by default — no toggle needed.
+"""
+
+import hashlib
+import json
+import logging
+from datetime import datetime, timedelta
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Base directory for daily message logs
+CONVERSATIONS_DIR = Path.home() / ".bone" / "conversations"
+RETENTION_DAYS = 7
+
+
+def _project_suffix(project_dir: Path) -> str:
+    """Generate a short suffix from a project directory path.
+
+    Format: {dirname}_{first 6 chars of SHA256(path)}
+    Avoids collisions between repos with the same folder name.
+    """
+    path_str = str(project_dir.resolve())
+    h = hashlib.sha256(path_str.encode()).hexdigest()[:6]
+    return f"{project_dir.name}_{h}"
+
+
+PROJECT_INDEX_FILE = CONVERSATIONS_DIR / ".project_index.jsonl"
+
+
+def _register_project(key: str, project_dir: Path) -> None:
+    """Append a key→path mapping to the project index if not already present."""
+    resolved = str(project_dir.resolve())
+    # Check if this key already maps to this path
+    if PROJECT_INDEX_FILE.exists():
+        with open(PROJECT_INDEX_FILE, "r", encoding="utf-8") as f:
+            for line in f:
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if entry.get("key") == key and entry.get("path") == resolved:
+                    return  # Already indexed
+    PROJECT_INDEX_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(PROJECT_INDEX_FILE, "a", encoding="utf-8") as f:
+        f.write(json.dumps({"key": key, "path": resolved}) + "\n")
+
+
+class UserMessageLogger:
+    """Logs user messages to daily JSONL files for later dream processing.
+
+    When a project_dir is provided, messages go to a per-project file:
+        {date}__{dirname}_{hash}.jsonl
+    Without a project_dir, messages go to the catch-all:
+        {date}.jsonl
+    """
+
+    def __init__(self, conversations_dir: Path | None = None):
+        self._dir = conversations_dir or CONVERSATIONS_DIR
+        self._dir.mkdir(parents=True, exist_ok=True)
+
+    def log_user_message(self, content: str, project_dir: Path | None = None) -> None:
+        """Append a single user message to today's JSONL file.
+
+        Args:
+            content: The user message text.
+            project_dir: Optional project root directory. If provided,
+                messages are written to a per-project file.
+
+        Opens in append mode and flushes immediately for crash safety.
+        Each message is one self-contained JSON line.
+        """
+        today = datetime.now().strftime("%Y-%m-%d")
+        if project_dir:
+            suffix = _project_suffix(project_dir)
+            _register_project(suffix, project_dir)
+            filepath = self._dir / f"{today}__{suffix}.jsonl"
+        else:
+            filepath = self._dir / f"{today}.jsonl"
+        entry = {"ts": datetime.now().isoformat(), "msg": content}
+        with open(filepath, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    @staticmethod
+    def cleanup_old_files(directory: Path | None = None, retention_days: int = RETENTION_DAYS) -> int:
+        """Delete JSONL files older than retention_days. Returns count of files removed."""
+        target_dir = directory or CONVERSATIONS_DIR
+        if not target_dir.exists():
+            return 0
+
+        cutoff = datetime.now() - timedelta(days=retention_days)
+        removed = 0
+        surviving = set()
+        for f in target_dir.glob("*.jsonl"):
+            if f.stat().st_mtime < cutoff.timestamp():
+                f.unlink()
+                removed += 1
+                logger.debug("Removed old conversation log: %s", f.name)
+            else:
+                surviving.add(f.name)
+
+        # Prune stale entries from the project index
+        index_file = target_dir / ".project_index.jsonl"
+        if index_file.exists():
+            kept: list[str] = []
+            for line in index_file.read_text(encoding="utf-8").splitlines():
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                key = entry.get("key", "")
+                # Keep entry if any file matching its key still exists
+                if any(key in name for name in surviving):
+                    kept.append(line)
+            index_file.write_text("\n".join(kept) + ("\n" if kept else ""), encoding="utf-8")
+
+        return removed

package/src/utils/validation.py

@@ -167,6 +167,16 @@ def check_command(command):
     if command.lower().startswith("powershell"):
         return False, "nested powershell invocation"
 
+    # Multi-line shell scripts/heredocs are valid command payloads.
+    # Do not tokenize the full script here: tokenization can reject valid shell
+    # syntax before the shell sees it. Safety/approval checks happen upstream.
+    if "\n" in command:
+        for line in command.splitlines():
+            line = line.strip()
+            if line and line.lower().startswith("powershell"):
+                return False, "nested powershell invocation"
+        return True, None
+
     # Basic validation - ensure command has content
     tokens = _tokenize_segment(command)
     if not tokens: