vmcode-cli 1.0.0

package/src/utils/editor.py

@@ -0,0 +1,158 @@
+"""External editor integration for vmCode."""
+import os
+import platform
+import subprocess
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Tuple, Optional
+
+
+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)
+
+    Returns:
+        str: Editor command or path
+    """
+    # 1. Check environment variable
+    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 ["nano", "vi", "vim"]:
+            if shutil.which(cmd):
+                return cmd
+        # Fallback to nano even if not found (will error later)
+        return "nano"
+
+
+def _create_temp_file() -> Tuple[Path, object]:
+    """Create temporary file for editing.
+
+    Returns:
+        tuple: (Path object, file handle)
+    """
+    # Create with .md extension for better syntax highlighting
+    temp_fd = tempfile.NamedTemporaryFile(
+        mode='w+',
+        suffix='.md',
+        prefix='vmcode_edit_',
+        delete=False,
+        encoding='utf-8'
+    )
+
+    temp_fd.flush()
+
+    return Path(temp_fd.name), temp_fd
+
+
+def _strip_comment_lines(content: str) -> str:
+    """Remove comment lines (starting with #) from content.
+
+    Args:
+        content: Raw content from editor
+
+    Returns:
+        str: Content with comment lines removed
+    """
+    lines = []
+    for line in content.split('\n'):
+        stripped = line.strip()
+        # Keep empty lines and non-comment lines
+        if not stripped.startswith('#'):
+            lines.append(line)
+
+    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.
+
+    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
+    """
+    editor_cmd = get_editor()
+    temp_path = None
+
+    try:
+        # Create temporary file
+        temp_path, temp_fd = _create_temp_file()
+        temp_fd.close()
+
+        if debug_mode:
+            console.print(f"[dim]Temp file: {temp_path}[/dim]")
+            console.print(f"[dim]Editor: {editor_cmd}[/dim]")
+
+        console.print("[cyan]Opening editor...[/cyan]")
+        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"
+
+        result = subprocess.run(
+            [editor_cmd, str(temp_path)],
+            shell=use_shell,
+            check=False  # Don't raise on non-zero exit
+        )
+
+        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)
+
+        if debug_mode:
+            console.print(f"[dim]Read {len(content)} characters[/dim]")
+
+        return (True, content)
+
+    except FileNotFoundError:
+        console.print(f"[red]Editor '{editor_cmd}' not found[/red]", markup=False)
+        console.print("[dim]Set EDITOR as environment variable[/dim]")
+        if debug_mode:
+            console.print(f"[dim]Tried to run: {editor_cmd}[/dim]")
+        return (False, None)
+
+    except PermissionError as e:
+        console.print(f"[red]Permission denied: {e}[/red]", markup=False)
+        console.print("[dim]Check permissions on temporary directory[/dim]")
+        return (False, None)
+
+    except Exception as e:
+        console.print(f"[red]Failed to open editor: {e}[/red]", markup=False)
+        if debug_mode:
+            import traceback
+            console.print(f"[dim]{traceback.format_exc()}[/dim]")
+        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]")
+            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]")

package/src/utils/gitignore_filter.py

@@ -0,0 +1,149 @@
+"""Centralized .gitignore filtering using pathspec library."""
+
+import logging
+from pathlib import Path
+from typing import Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# Always allow .gitignore itself to be read/edited
+ALWAYS_ALLOWED_FILES = {".gitignore"}
+
+# Try to import pathspec at module level
+try:
+    import pathspec
+except ImportError:
+    pathspec = None
+    logger.warning("pathspec library not installed - .gitignore filtering disabled")
+
+
+def load_gitignore_spec(repo_root: Path):
+    """Load .gitignore patterns into a PathSpec object.
+
+    Args:
+        repo_root: Repository root directory
+
+    Returns:
+        pathspec.PathSpec or None if .gitignore doesn't exist
+    """
+    # Return None early if pathspec is not available
+    if pathspec is None:
+        return None
+
+    gitignore_path = repo_root / ".gitignore"
+
+    if not gitignore_path.exists():
+        return None
+
+    try:
+        # Read .gitignore patterns
+        patterns = gitignore_path.read_text(encoding="utf-8").splitlines()
+
+        # Create PathSpec with gitwildmatch (git's pattern matching)
+        spec = pathspec.PathSpec.from_lines("gitwildmatch", patterns)
+        return spec
+
+    except Exception as e:
+        logger.warning(f"Failed to load .gitignore: {e}")
+        return None
+
+
+def is_path_ignored(
+    path: Path, repo_root: Path, gitignore_spec
+) -> Tuple[bool, Optional[str]]:
+    """Check if a path is ignored by .gitignore.
+
+    Args:
+        path: Absolute path to check
+        repo_root: Repository root directory
+        gitignore_spec: pathspec.PathSpec object (or None)
+
+    Returns:
+        Tuple of (is_ignored, matched_pattern)
+        - is_ignored: True if path should be blocked
+        - matched_pattern: The pattern that matched (or None)
+    """
+    # No filtering if no .gitignore
+    if gitignore_spec is None:
+        return False, None
+
+    # Always allow .gitignore itself
+    if path.name in ALWAYS_ALLOWED_FILES:
+        return False, None
+
+    # Get relative path from repo root (gitignore only applies within repo)
+    try:
+        rel_path = path.relative_to(repo_root)
+    except ValueError:
+        # Path is outside repo - gitignore doesn't apply
+        return False, None
+
+    # Convert to forward slashes (git convention)
+    rel_path_str = str(rel_path).replace("\\", "/")
+
+    # Check if path matches any .gitignore pattern
+    # pathspec.match_file() returns True if the file should be ignored
+    if gitignore_spec.match_file(rel_path_str):
+        # Find which pattern matched (for better error messages)
+        matched_pattern = _find_matching_pattern(rel_path_str, gitignore_spec)
+        return True, matched_pattern
+
+    return False, None
+
+
+def _find_matching_pattern(path_str: str, gitignore_spec) -> Optional[str]:
+    """Find which .gitignore pattern matched a path.
+
+    This is for better error messages.
+
+    Args:
+        path_str: Relative path string (with forward slashes)
+        gitignore_spec: pathspec.PathSpec object
+
+    Returns:
+        The matching pattern string, or None
+    """
+    try:
+        # PathSpec stores patterns internally
+        for pattern in gitignore_spec.patterns:
+            if pattern.match_file(path_str):
+                # Return the original pattern string
+                return pattern.pattern
+    except Exception:
+        pass
+
+    return None
+
+
+def format_gitignore_error(
+    path: Path, repo_root: Path, matched_pattern: Optional[str]
+) -> str:
+    """Format a user-friendly error message for .gitignore blocked files.
+
+    Args:
+        path: The blocked file path
+        repo_root: Repository root
+        matched_pattern: The .gitignore pattern that matched
+
+    Returns:
+        Formatted error message
+    """
+    try:
+        rel_path = path.relative_to(repo_root)
+    except ValueError:
+        rel_path = path
+
+    error_msg = (
+        f"exit_code=ERROR_GITIGNORE_BLOCKED\n"
+        f"File blocked by .gitignore: {rel_path}\n\n"
+    )
+    error_msg += "This file matches patterns in .gitignore and cannot be accessed.\n"
+
+    if matched_pattern:
+        error_msg += f"Matched pattern: {matched_pattern}\n"
+
+    error_msg += "\nTo access this file:\n"
+    error_msg += "1. Remove it from .gitignore, or\n"
+    error_msg += "2. Use git commands directly (git show, git diff)\n"
+
+    return error_msg

package/src/utils/logger.py

@@ -0,0 +1,254 @@
+"""Markdown conversation logging module for saving chat history to readable markdown files."""
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+
+logger = logging.getLogger(__name__)
+
+
+class MarkdownConversationLogger:
+    """Logs conversations to Markdown format with tool call details."""
+
+    MAX_CONTENT_LENGTH = 2000
+
+    def __init__(self, conversations_dir: str = "conversations"):
+        """Initialize markdown conversation logger.
+
+        Args:
+            conversations_dir: Directory to save conversation logs
+        """
+        self.conversations_dir = Path(conversations_dir)
+        self.conversations_dir.mkdir(exist_ok=True)
+        self.current_file: Optional[Path] = None
+
+    def start_session(self):
+        """Start a new conversation session."""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self.current_file = self.conversations_dir / f"conversation_{timestamp}.md"
+        logger.info(f"Started markdown conversation logging to {self.current_file}")
+
+        # Write header
+        with open(self.current_file, 'w', encoding='utf-8') as f:
+            f.write(f"# Conversation Log\n\n")
+            f.write(f"**Started:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+            f.write("---\n\n")
+
+    def _format_tool_call(self, tool_call: Dict[str, Any]) -> str:
+        """Format a tool call for markdown display.
+
+        Args:
+            tool_call: Tool call dict with id, type, function
+
+        Returns:
+            Formatted markdown string
+        """
+        fn = tool_call.get("function", {})
+        name = fn.get("name", "unknown")
+        arguments = fn.get("arguments", "{}")
+        args_str = self._format_json_value(arguments)
+
+        return f"""### {name}
+
+```json
+{args_str}
+```"""
+
+    def _format_json_value(self, value: Any) -> str:
+        """Format a value as JSON for markdown display.
+
+        Args:
+            value: Value to format (string, dict, or other)
+
+        Returns:
+            Formatted JSON string, or string representation if not JSON-serializable
+        """
+        try:
+            if isinstance(value, str):
+                parsed = json.loads(value)
+            else:
+                parsed = value
+            return json.dumps(parsed, indent=2, ensure_ascii=False)
+        except (json.JSONDecodeError, TypeError):
+            return str(value)
+
+    def _format_tool_call_inline(self, arguments: Any) -> str:
+        """Format tool call arguments as JSON for inline display.
+
+        Args:
+            arguments: Tool call arguments (string or dict)
+
+        Returns:
+            Formatted JSON string
+        """
+        args_str = self._format_json_value(arguments)
+        return f"```json\n{args_str}\n```"
+
+    def _format_tool_result(self, message: Dict[str, Any]) -> str:
+        """Format a tool result for markdown display.
+
+        Args:
+            message: Tool result message with role, tool_call_id, content
+
+        Returns:
+            Formatted markdown string
+        """
+        content = message.get("content", "")
+
+        # Truncate very long outputs
+        if len(content) > self.MAX_CONTENT_LENGTH:
+            content = content[:self.MAX_CONTENT_LENGTH] + "\n\n... (truncated)"
+
+        # Try to format as code if it looks like structured output
+        if content and (content.startswith("{") or content.startswith("[")):
+            try:
+                parsed = json.loads(content)
+                content = json.dumps(parsed, indent=2, ensure_ascii=False)
+                return f"```\n{content}\n```\n"
+            except json.JSONDecodeError:
+                pass
+
+        return f"```\n{content}\n```\n"
+
+    def _format_message(self, message: Dict[str, Any], skip_tool_calls: bool = False) -> str:
+        """Convert a message dict to markdown format.
+
+        Args:
+            message: Message dict with role, content, tool_calls, etc.
+            skip_tool_calls: If True, don't include tool_calls section
+
+        Returns:
+            Formatted markdown string
+        """
+        role = message.get("role", "unknown")
+        content = message.get("content", "")
+
+        if role == "user":
+            emoji = "👤"
+            title = "User"
+        elif role == "assistant":
+            emoji = "🤖"
+            title = "Assistant"
+        elif role == "tool":
+            # Tool results are handled separately with their tool calls
+            return None
+        elif role == "system":
+            emoji = "⚙️"
+            title = "System"
+        else:
+            emoji = "📝"
+            title = role.capitalize()
+
+        md = f"\n## {emoji} {title}\n\n"
+
+        # Add content if present
+        if content:
+            md += f"{content}\n\n"
+
+        # Add tool calls if present (skip when skip_tool_calls=True)
+        if not skip_tool_calls and message.get("tool_calls"):
+            md += "### 🔧 Tool Calls\n\n"
+            for tc in message["tool_calls"]:
+                md += self._format_tool_call(tc) + "\n"
+
+        return md
+
+    def log_message(self, message: Dict[str, Any]):
+        """Append a message to the current markdown file.
+
+        Args:
+            message: Message dict with 'role' and 'content' keys, optionally 'tool_calls'
+        """
+        if not self.current_file:
+            self.start_session()
+
+        # Check if this is a tool result - we'll handle it differently
+        if message.get("role") == "tool":
+            # Find the associated tool call by tool_call_id
+            tool_call_id = message.get("tool_call_id")
+            formatted = f"\n### 📋 Tool Result (ID: `{tool_call_id}`)\n\n"
+            formatted += self._format_tool_result(message) + "\n"
+        else:
+            formatted = self._format_message(message)
+
+        if formatted:
+            with open(self.current_file, 'a', encoding='utf-8') as f:
+                f.write(formatted)
+
+    def rewrite_log(self, messages: List[Dict[str, Any]]):
+        """Rewrite the current markdown log to match the provided messages.
+
+        Args:
+            messages: Full message list to persist
+        """
+        if not self.current_file:
+            self.start_session()
+
+        # Rewrite entire file
+        with open(self.current_file, 'w', encoding='utf-8') as f:
+            # Write header
+            f.write(f"# Conversation Log\n\n")
+            f.write(f"**Started:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+            f.write(f"**Last Updated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+            f.write("---\n\n")
+
+            # Track tool calls to pair with results
+            pending_tool_calls = {}
+
+            for message in messages:
+                role = message.get("role")
+
+                if role == "assistant" and message.get("tool_calls"):
+                    # Store tool calls for later pairing with results
+                    for tc in message["tool_calls"]:
+                        pending_tool_calls[tc["id"]] = tc
+
+                    # Write the assistant message (skip tool_calls section)
+                    formatted = self._format_message(message, skip_tool_calls=True)
+                    if formatted:
+                        f.write(formatted)
+
+                elif role == "tool":
+                    # This is a tool result, pair it with the call
+                    tool_call_id = message.get("tool_call_id")
+                    tc = pending_tool_calls.get(tool_call_id)
+
+                    if tc:
+                        # Write tool call with result together
+                        fn = tc.get("function", {})
+                        name = fn.get("name", "unknown")
+                        arguments = fn.get("arguments", "{}")
+
+                        f.write(f"\n### 🔧 Tool Call: {name}\n\n")
+                        f.write(self._format_tool_call_inline(arguments) + "\n\n")
+                        f.write(f"**Result:**\n\n")
+                    else:
+                        # Orphaned result (no matching call)
+                        f.write(f"\n### 🔧 Tool Result (ID: `{tool_call_id}`)\n\n")
+
+                    f.write(self._format_tool_result(message) + "\n")
+
+                else:
+                    # Regular message (user, system)
+                    formatted = self._format_message(message)
+                    if formatted:
+                        f.write(formatted)
+
+            # Write footer
+            f.write("\n---\n\n")
+            f.write(f"*End of conversation*\n")
+
+    def end_session(self):
+        """End the current conversation logging session."""
+        if not self.current_file:
+            return
+
+        # Add footer
+        with open(self.current_file, 'a', encoding='utf-8') as f:
+            f.write("\n---\n\n")
+            f.write(f"**Ended:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+
+        logger.info(f"Ended markdown conversation session: {self.current_file.name}")
+        self.current_file = None

package/src/utils/markdown.py

@@ -0,0 +1,32 @@
+"""Markdown preprocessing utilities for vmCode."""
+
+import re
+
+
+def left_align_headings(markdown: str) -> str:
+    """Convert markdown headings to bold text to avoid Rich's centering.
+    
+    Rich's Markdown renderer centers headings by default. This function
+    converts them to bold text for consistent left alignment.
+    
+    Args:
+        markdown: Raw markdown string
+        
+    Returns:
+        Markdown string with headings converted to bold
+    """
+    # Replace headings with bold text
+    # h1-h6 with optional leading whitespace
+    patterns = [
+        (r'^###### (.+)$', r'******\1******'),  # h6 -> bold
+        (r'^##### (.+)$', r'*****\1*****'),      # h5 -> bold  
+        (r'^#### (.+)$', r'****\1****'),         # h4 -> bold
+        (r'^### (.+)$', r'***\1***'),            # h3 -> bold
+        (r'^## (.+)$', r'**\1**'),               # h2 -> bold
+        (r'^# (.+)$', r'**\1**'),                # h1 -> bold
+    ]
+    
+    for pattern, replacement in patterns:
+        markdown = re.sub(pattern, replacement, markdown, flags=re.MULTILINE)
+    
+    return markdown

package/src/utils/settings.py

@@ -0,0 +1,94 @@
+"""Centralized configuration for vmCode."""
+from dataclasses import dataclass, field
+from typing import Set
+
+# Load config from llm.config
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from llm.config import _CONFIG
+
+# Styles and themes
+from pygments.styles.monokai import MonokaiStyle
+
+
+class MonokaiDarkBGStyle(MonokaiStyle):
+    """Monokai style with dark background for code highlighting."""
+    background_color = "#141414"
+
+
+@dataclass
+class ServerSettings:
+    """Local llama-server configuration."""
+    ngl_layers: int = field(default_factory=lambda: _CONFIG.get("SERVER_SETTINGS", {}).get("ngl_layers", 30))
+    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))
+    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))
+
+
+@dataclass
+class ToolSettings:
+    """Tool execution limits and defaults."""
+    max_tool_calls: int = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("max_tool_calls", 100))
+    command_timeout_sec: int = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("command_timeout_sec", 30))
+    enable_parallel_execution: bool = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("enable_parallel_execution", True))
+    max_parallel_workers: int = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("max_parallel_workers", 10))
+    max_command_output_lines: int = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("max_command_output_lines", 100))
+    max_file_preview_lines: int = field(default_factory=lambda: _CONFIG.get("TOOL_SETTINGS", {}).get("max_file_preview_lines", 200))
+
+
+@dataclass
+class FileSettings:
+    """File scanning and reading limits."""
+    max_file_bytes: int = field(default_factory=lambda: _CONFIG.get("FILE_SETTINGS", {}).get("max_file_bytes", 200_000))
+    max_total_bytes: int = field(default_factory=lambda: _CONFIG.get("FILE_SETTINGS", {}).get("max_total_bytes", 1_500_000))
+    exclude_dirs: Set[str] = None
+
+    def __post_init__(self):
+        if self.exclude_dirs is None:
+            config_exclude = _CONFIG.get("FILE_SETTINGS", {}).get("exclude_dirs")
+            if config_exclude:
+                self.exclude_dirs = set(config_exclude)
+            else:
+                self.exclude_dirs = {".git", ".venv", "llama.cpp", "bin", "__pycache__"}
+
+
+@dataclass
+class ToolCompactionSettings:
+    """Per-message tool result compaction settings."""
+    enable_per_message_compaction: bool = field(default_factory=lambda: _CONFIG.get("CONTEXT_SETTINGS", {}).get("tool_compaction", {}).get("enable_per_message_compaction", True))
+    keep_recent_tool_blocks: int = field(default_factory=lambda: _CONFIG.get("CONTEXT_SETTINGS", {}).get("tool_compaction", {}).get("keep_recent_tool_blocks", 3))
+    compact_failed_tools: bool = field(default_factory=lambda: _CONFIG.get("CONTEXT_SETTINGS", {}).get("tool_compaction", {}).get("compact_failed_tools", True))
+
+
+@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", 75_000))
+    hard_limit_tokens: int = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("hard_limit_tokens", 300_000))
+    enable_compaction: bool = field(default_factory=lambda: _CONFIG.get("SUB_AGENT_SETTINGS", {}).get("enable_compaction", False))
+
+
+# Context compaction settings
+@dataclass
+class ContextSettings:
+    """Context compaction thresholds and defaults."""
+    compact_trigger_tokens: int = field(default_factory=lambda: _CONFIG.get("CONTEXT_SETTINGS", {}).get("compact_trigger_tokens", 100_000))
+    log_conversations: bool = field(default_factory=lambda: _CONFIG.get("CONTEXT_SETTINGS", {}).get("log_conversations", False))
+    conversations_dir: str = field(default_factory=lambda: _CONFIG.get("CONTEXT_SETTINGS", {}).get("conversations_dir", "conversations"))
+    tool_compaction: ToolCompactionSettings = field(default_factory=ToolCompactionSettings)
+
+
+# Global instances
+server_settings = ServerSettings()
+tool_settings = ToolSettings()
+file_settings = FileSettings()
+context_settings = ContextSettings()
+sub_agent_settings = SubAgentSettings()
+
+# Tool execution constants
+MAX_TOOL_CALLS = tool_settings.max_tool_calls
+MAX_COMMAND_OUTPUT_LINES = tool_settings.max_command_output_lines
+MAX_FILE_PREVIEW_LINES = tool_settings.max_file_preview_lines