vmcode-cli 1.0.0

package/src/core/config_manager.py

@@ -0,0 +1,269 @@
+
+
+from pathlib import Path
+import shutil
+from typing import Dict, Any, Optional
+import logging
+import yaml
+from llm import config as llm_config
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigManager:
+
+    def __init__(self, config_path: Optional[Path] = None):
+        self.config_path = config_path or llm_config.CONFIG_PATH
+        self._cached_data = None
+
+    def load(self, force_reload: bool = False) -> Dict[str, Any]:
+        """Load configuration from file, using cache if available.
+
+        Args:
+            force_reload: If True, bypass cache and reload from disk
+
+        Returns:
+            Configuration dictionary
+        """
+        if not force_reload and self._cached_data is not None:
+            return self._cached_data
+
+        if not self.config_path.exists():
+            self._cached_data = llm_config.generate_config_template()
+            return self._cached_data
+
+        try:
+            with open(self.config_path, 'r', encoding='utf-8-sig') as f:
+                self._cached_data = yaml.safe_load(f) or {}
+                return self._cached_data
+        except yaml.YAMLError as e:
+            logger.error(f"Failed to parse config file {self.config_path}: {e}")
+            logger.warning("Using default configuration template")
+            self._cached_data = llm_config.generate_config_template()
+            return self._cached_data
+
+    def save(self, config_data: Dict[str, Any], create_backup: bool = False):
+        if create_backup and self.config_path.exists():
+            backup_path = self.config_path.with_suffix('.backup')
+            shutil.copy2(self.config_path, backup_path)
+
+        with open(self.config_path, 'w', encoding='utf-8-sig') as f:
+            yaml.dump(config_data, f, default_flow_style=False, sort_keys=False, allow_unicode=True)
+
+        self._cached_data = config_data
+        # Note: Config is read from disk on reload. Call reload_config() after changes.
+
+    def update_field(self, key: str, value: Any, create_backup: bool = False) -> Optional[Path]:
+        """Update a single configuration field.
+
+        Args:
+            key: Configuration key to update
+            value: New value for the key
+            create_backup: If True, create a backup before saving
+
+        Returns:
+            Backup path if backup was created, None otherwise
+        """
+        config_data = self.load(force_reload=True)
+        config_data[key] = value
+
+        backup_path = None
+        if create_backup and self.config_path.exists():
+            backup_path = self.config_path.with_suffix('.backup')
+
+        self.save(config_data, create_backup=create_backup)
+        return backup_path
+
+    def set_provider(self, provider_name: str) -> Optional[Path]:
+        return self.update_field('LAST_PROVIDER', provider_name)
+
+    def _extract_model_pricing(self, config_data: Dict[str, Any], model: str) -> Dict[str, float]:
+        """Extract pricing for a model from config.
+
+        Args:
+            config_data: Configuration dictionary
+            model: Model name to look up
+
+        Returns:
+            Dict with 'in' and 'out' cost values per 1M tokens
+        """
+        model_prices = config_data.get('MODEL_PRICES', {})
+        if model and model in model_prices:
+            model_cost = model_prices[model]
+            return {
+                'in': float(model_cost.get('cost_in', 0.0)),
+                'out': float(model_cost.get('cost_out', 0.0))
+            }
+        return {'in': 0.0, 'out': 0.0}
+
+    def get_usage_costs(self, provider: str = None, model: str = None) -> Dict[str, float]:
+        """Get usage costs for a specific model.
+
+        Args:
+            provider: Provider name (e.g., 'openrouter', 'glm', 'openai').
+                     If None, uses the last provider from config.
+            model: Model name (e.g., 'minimax/minimax-m2.5', 'GLM-4.7').
+                   If None, uses the current model from the provider.
+
+        Returns:
+            Dict with 'in' and 'out' cost values per 1M tokens
+        """
+        config_data = self.load()
+
+        if provider is None:
+            provider = config_data.get('LAST_PROVIDER', 'glm')
+
+        # Get model name from config if not provided
+        if model is None:
+            provider_model_map = {
+                'vmcode_free': 'VMCODE_FREE_MODEL',
+                'openrouter': 'OPENROUTER_MODEL',
+                'glm': 'GLM_MODEL',
+                'openai': 'OPENAI_MODEL',
+                'gemini': 'GEMINI_MODEL',
+                'minimax': 'MINIMAX_MODEL',
+                'anthropic': 'ANTHROPIC_MODEL',
+                'kimi': 'KIMI_MODEL'
+            }
+            model_key = provider_model_map.get(provider.lower())
+            if model_key:
+                model = config_data.get(model_key, '')
+
+        return self._extract_model_pricing(config_data, model)
+
+    def set_model(self, provider_name: str, model: str) -> Optional[Path]:
+        """Set model for a specific provider.
+
+        Args:
+            provider_name: Provider name (e.g., 'openrouter', 'glm', 'local', 'openai')
+            model: Model name/path to set
+
+        Returns:
+            Backup path if backup was created, None otherwise
+        """
+        # Map provider names to their config keys
+        provider_keys = {
+            'local': 'LOCAL_MODEL_PATH',
+            'openrouter': 'OPENROUTER_MODEL',
+            'glm': 'GLM_MODEL',
+            'openai': 'OPENAI_MODEL',
+            'gemini': 'GEMINI_MODEL',
+            'minimax': 'MINIMAX_MODEL',
+            'anthropic': 'ANTHROPIC_MODEL',
+            'kimi': 'KIMI_MODEL'
+        }
+
+        if provider_name not in provider_keys:
+            raise ValueError(f"Unknown provider: {provider_name}")
+
+        key = provider_keys[provider_name]
+        return self.update_field(key, model)
+
+    def set_api_key(self, provider_name: str, api_key: str) -> Optional[Path]:
+        """Set API key for a specific provider.
+
+        Args:
+            provider_name: Provider name (e.g., 'openrouter', 'glm', 'openai')
+            api_key: API key to set
+
+        Returns:
+            Backup path if backup was created, None otherwise
+        """
+        # Map provider names to their config keys
+        provider_keys = {
+            'openrouter': 'OPENROUTER_API_KEY',
+            'glm': 'GLM_API_KEY',
+            'openai': 'OPENAI_API_KEY',
+            'gemini': 'GEMINI_API_KEY',
+            'minimax': 'MINIMAX_API_KEY',
+            'anthropic': 'ANTHROPIC_API_KEY',
+            'kimi': 'KIMI_API_KEY'
+        }
+
+        if provider_name not in provider_keys:
+            raise ValueError(f"Unknown provider: {provider_name}")
+
+        key = provider_keys[provider_name]
+        return self.update_field(key, api_key)
+
+    def get_pre_tool_planning(self) -> bool:
+        """Get the pre-tool planning enabled state.
+
+        Returns:
+            True if pre-tool planning is enabled, False otherwise.
+            Defaults to False if not set in config.
+        """
+        config_data = self.load()
+        return bool(config_data.get('PRE_TOOL_PLANNING', False))
+
+    def set_pre_tool_planning(self, enabled: bool) -> Optional[Path]:
+        """Set the pre-tool planning enabled state.
+
+        Args:
+            enabled: True to enable pre-tool planning, False to disable.
+
+        Returns:
+            Backup path if backup was created, None otherwise.
+        """
+        return self.update_field('PRE_TOOL_PLANNING', enabled)
+
+    def get_model_price(self, model_name: str) -> Dict[str, float]:
+        """Get pricing for a specific model.
+
+        Args:
+            model_name: Model name (e.g., 'minimax/minimax-m2.5', 'GLM-4.7')
+
+        Returns:
+            Dict with 'in' and 'out' cost values per 1M tokens
+        """
+        config_data = self.load()
+        return self._extract_model_pricing(config_data, model_name)
+
+    def set_model_price(self, model_name: str, cost_in: float, cost_out: float) -> Optional[Path]:
+        """Set pricing for a specific model.
+
+        Args:
+            model_name: Model name (e.g., 'minimax/minimax-m2.5', 'GLM-4.7')
+            cost_in: Cost per 1M input tokens
+            cost_out: Cost per 1M output tokens
+
+        Returns:
+            Backup path if backup was created, None otherwise
+        """
+        config_data = self.load(force_reload=True)
+
+        if 'MODEL_PRICES' not in config_data:
+            config_data['MODEL_PRICES'] = {}
+
+        config_data['MODEL_PRICES'][model_name] = {
+            'cost_in': cost_in,
+            'cost_out': cost_out
+        }
+
+        return self.save(config_data, create_backup=False)
+
+    def list_model_prices(self) -> Dict[str, Dict[str, float]]:
+        """Get all model-specific pricing.
+
+        Returns:
+            Dict mapping model names to their pricing (cost_in/cost_out per 1M tokens)
+        """
+        config_data = self.load()
+        return config_data.get('MODEL_PRICES', {})
+
+    def delete_model_price(self, model_name: str) -> Optional[Path]:
+        """Delete pricing for a specific model.
+
+        Args:
+            model_name: Model name to remove from pricing
+
+        Returns:
+            Backup path if backup was created, None otherwise
+        """
+        config_data = self.load(force_reload=True)
+
+        if 'MODEL_PRICES' in config_data and model_name in config_data['MODEL_PRICES']:
+            del config_data['MODEL_PRICES'][model_name]
+            return self.save(config_data, create_backup=False)
+
+        return None

package/src/core/init.py

@@ -0,0 +1,161 @@
+"""Repository scan and agents.md generation."""
+
+from pathlib import Path
+from typing import List, Tuple
+
+from llm.client import LLMClient
+from utils.settings import file_settings
+
+
+EXCLUDE_DIRS = file_settings.exclude_dirs
+MAX_FILE_BYTES = file_settings.max_file_bytes
+MAX_TOTAL_BYTES = file_settings.max_total_bytes
+
+
+def _is_excluded(path: Path, repo_root: Path) -> bool:
+    rel_parts = path.relative_to(repo_root).parts
+    return any(part in EXCLUDE_DIRS for part in rel_parts)
+
+
+def _read_file(path: Path) -> Tuple[str, str]:
+    size = path.stat().st_size
+    if size > MAX_FILE_BYTES:
+        return "skipped_large", ""
+
+    raw = path.read_bytes()
+    if b"\x00" in raw:
+        return "skipped_binary", ""
+
+    text = raw.decode("utf-8", errors="replace")
+    return "ok", text
+
+
+def _collect_files(repo_root: Path) -> List[Path]:
+    """Collect files from repository, respecting EXCLUDE_DIRS and .gitignore.
+
+    Args:
+        repo_root: Repository root directory
+
+    Returns:
+        List of Path objects for files to include
+    """
+    from utils.gitignore_filter import load_gitignore_spec, is_path_ignored
+
+    # Load .gitignore spec
+    gitignore_spec = load_gitignore_spec(repo_root)
+
+    files = []
+    for path in repo_root.rglob("*"):
+        if not path.is_file():
+            continue
+
+        # Check hard-coded exclusions
+        if _is_excluded(path, repo_root):
+            continue
+
+        # Check .gitignore
+        if gitignore_spec is not None:
+            is_ignored, _ = is_path_ignored(path, repo_root, gitignore_spec)
+            if is_ignored:
+                continue
+
+        files.append(path)
+
+    return sorted(files, key=lambda p: str(p.relative_to(repo_root)))
+
+
+def _build_prompt(repo_root: Path, files: List[Path]) -> str:
+    total_bytes = 0
+    file_blocks = []
+    for path in files:
+        rel_path = path.relative_to(repo_root)
+        status, text = _read_file(path)
+        size = path.stat().st_size
+
+        if status == "ok":
+            if total_bytes + len(text.encode("utf-8")) > MAX_TOTAL_BYTES:
+                status = "skipped_total_limit"
+                text = ""
+            else:
+                total_bytes += len(text.encode("utf-8"))
+
+        if status == "ok":
+            content = text
+        elif status == "skipped_large":
+            content = "[skipped: file too large]"
+        elif status == "skipped_binary":
+            content = "[skipped: binary file]"
+        else:
+            content = "[skipped: total content limit reached]"
+
+        block = (
+            f"FILE: {rel_path}\n"
+            f"SIZE: {size}\n"
+            f"CONTENT:\n{content}\n"
+        )
+        file_blocks.append(block)
+
+    files_payload = "\n".join(file_blocks)
+    return (
+        "Generate a concise agents.md for this repository.\n\n"
+        "CRITICAL: Be extremely concise. Single-line descriptions only.\n\n"
+        "Requirements:\n"
+        "1) '# Files' section - bullets: `path` - one-line description\n"
+        "2) '# Key Classes' section - bullets: **Class** (`path`) - one-line responsibility\n"
+        "3) '# Architecture' section - compact flow diagrams showing entry points, data flow, tool-calling loop\n"
+        "4) '# Configuration' section - grouped bullets: `VAR_1`, `VAR_2` - purpose\n"
+        "5) '# Patterns' section - bullets: **Category**: description\n"
+        "6) '# Summary' section - 1-2 sentences max\n\n"
+        "Style rules:\n"
+        "- One line per file/class description\n"
+        "- No verbose explanations or implementation details\n"
+        "- Use arrows (→) for flows instead of numbered lists\n"
+        "- Group related config vars on single line\n"
+        "- Focus on WHAT and WHERE, not HOW\n"
+        "- Return ONLY markdown, no code blocks\n\n"
+        f"REPO_ROOT: {repo_root}\n\n"
+        f"{files_payload}"
+    )
+
+
+def run_init(repo_root: Path, console) -> None:
+    """Scan repo files with the LLM and write agents.md."""
+    console.print("[yellow]Generating agents.md with LLM scan...[/yellow]")
+
+    files = _collect_files(repo_root)
+    if not files:
+        console.print("[red]No files found to scan.[/red]")
+        return
+
+    prompt = _build_prompt(repo_root, files)
+    client = LLMClient()
+
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a documentation generator for a codebase. "
+                "Follow the user's formatting requirements exactly."
+            ),
+        },
+        {"role": "user", "content": prompt},
+    ]
+
+    response = client.chat_completion(messages, stream=False)
+    if isinstance(response, str):
+        console.print(f"[red]{response}[/red]", markup=False)
+        return
+
+    content = None
+    try:
+        content = response["choices"][0]["message"]["content"]
+    except (KeyError, IndexError, TypeError):
+        content = None
+
+    if not content or not content.strip():
+        console.print("[red]LLM returned empty content.[/red]")
+        return
+
+    output_path = Path(__file__).resolve().parents[1] / "agents.md"
+    output_path.write_text(content.strip() + "\n", encoding="utf-8")
+    console.print(f"[green]Generated {output_path.name} successfully![/green]")

package/src/core/sub_agent.py

@@ -0,0 +1,174 @@
+"""Sub-agent for delegated tasks.
+
+Uses existing AgenticOrchestrator with isolated message context
+and read-only tools to execute generic delegated tasks.
+"""
+
+from pathlib import Path
+
+from core.agentic import AgenticOrchestrator
+from core.chat_manager import ChatManager
+from llm.prompts import build_sub_agent_prompt
+from utils.settings import sub_agent_settings
+
+
+# Read-only tools allowed for sub-agent
+SUB_AGENT_TOOLS = ["rg", "read_file", "list_directory", "web_search"]
+
+
+def _create_chat_manager():
+    """Create a fresh ChatManager instance for sub-agent use.
+
+    Returns:
+        ChatManager: A new ChatManager instance with pre-configured system prompt
+    """
+    # Subagent uses configurable compaction setting (disabled by default)
+    if sub_agent_settings.enable_compaction:
+        # Use default compaction trigger from context_settings if enabled
+        chat_manager = ChatManager()
+    else:
+        # Disable compaction by passing None (no auto-compaction)
+        chat_manager = ChatManager(compact_trigger_tokens=None)
+
+    # Build sub-agent prompt with token awareness (use configurable soft limit)
+    base_prompt = build_sub_agent_prompt()
+    token_usage = chat_manager.token_tracker.get_usage_for_prompt(
+        context_limit=sub_agent_settings.soft_limit_tokens
+    )
+
+    # Inject token usage into sub-agent system prompt
+    chat_manager.messages = [{"role": "system", "content": f"{base_prompt}\n\n{token_usage}"}]
+    
+    # Load agents.md if it exists in current working directory
+    agents_path = Path.cwd() / "agents.md"
+    if agents_path.exists():
+        map_content = agents_path.read_text(encoding="utf-8").strip()
+        user_msg = (
+            "Here is the codebase map for this project. "
+            "This provides an overview of the repository structure and file purposes. "
+            "Use this as a reference when exploring the codebase.\n\n"
+            f"## Codebase Map (auto-generated from agents.md)\n\n{map_content}"
+        )
+        assistant_msg = (
+            "I've received the codebase map. I'll use this as a reference when "
+            "exploring the repository, but I'll always verify current state by "
+            "reading files and searching the codebase before making changes."
+        )
+        chat_manager.messages.append({"role": "user", "content": user_msg})
+        chat_manager.messages.append({"role": "assistant", "content": assistant_msg})
+    
+    # No conversation logging for sub-agent (isolated)
+    chat_manager.conversation_logger = None
+    # CRITICAL: Force plan mode to restrict dangerous tools
+    chat_manager.interaction_mode = "plan"
+    return chat_manager
+
+
+def run_sub_agent(
+    task_query: str,
+    repo_root: Path,
+    rg_exe_path: str,
+    console=None,
+    panel_updater=None,
+) -> dict:
+    """Run sub-agent using existing AgenticOrchestrator for delegated tasks.
+
+    Args:
+        task_query: Generic task query to execute (e.g., "Read file config.json")
+        repo_root: Repository root path
+        rg_exe_path: Path to rg executable
+        console: Optional Rich console for output
+        panel_updater: Optional SubAgentPanel for live panel updates
+
+    Returns:
+        Dict with:
+            - 'result': Formatted markdown string (goes into chat history)
+            - 'usage': Usage data for billing
+            - 'error': Error message if failed (None if success)
+    """
+    # Validate panel_updater type if provided
+    if panel_updater is not None and not hasattr(panel_updater, 'append'):
+        panel_updater = None
+
+    # Create fresh ChatManager for sub-agent
+    temp_chat_manager = _create_chat_manager()
+
+    # Create orchestrator (reuses existing implementation)
+    orchestrator = AgenticOrchestrator(
+        chat_manager=temp_chat_manager,
+        repo_root=repo_root,
+        rg_exe_path=rg_exe_path,
+        console=console,
+        debug_mode=False,
+        suppress_result_display=True,
+        is_sub_agent=True,
+        panel_updater=panel_updater,
+        pre_tool_planning_enabled=False,
+        force_parallel_execution=True  # Enable parallel execution for read-only tools
+    )
+
+    # Wrap orchestrator.run to check hard limit before each LLM call
+    original_get_llm_response = orchestrator._get_llm_response
+
+    def _get_llm_response_with_hard_limit(allowed_tools=None):
+        """Wrapper to check hard token limit before each LLM call."""
+        # Check hard token limit before making LLM call
+        current_total = temp_chat_manager.token_tracker.total_tokens
+        if current_total >= sub_agent_settings.hard_limit_tokens:
+            raise Exception(
+                f"Sub-agent hard token limit exceeded: "
+                f"{current_total:,} / {sub_agent_settings.hard_limit_tokens:,} tokens. "
+                "Please refine your query or use more targeted searches."
+            )
+
+        return original_get_llm_response(allowed_tools=allowed_tools)
+
+    # Replace the method with our wrapper
+    orchestrator._get_llm_response = _get_llm_response_with_hard_limit
+
+    try:
+        # Run sub-agent task
+        orchestrator.run(
+            task_query,
+            thinking_indicator=None,
+            allowed_tools=SUB_AGENT_TOOLS
+        )
+    except Exception as e:
+        return {
+            "result": "",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+            },
+            "error": str(e)
+        }
+
+    # Get final token usage (no need for delta calculation on fresh instance)
+    delta_prompt = temp_chat_manager.token_tracker.total_prompt_tokens
+    delta_completion = temp_chat_manager.token_tracker.total_completion_tokens
+    delta_total = temp_chat_manager.token_tracker.total_tokens
+
+    # Extract final response (last assistant message with content)
+    final_content = ""
+    for msg in reversed(temp_chat_manager.messages):
+        if msg.get("role") == "assistant" and msg.get("content"):
+            final_content = msg["content"].strip()
+            break
+
+    # Format with usage at end
+    result = (
+        f"{final_content}\n\n"
+        f"---\n"
+        f"Sub-agent used: {delta_prompt} prompt tokens, {delta_completion} completion tokens ({delta_total} total)"
+    )
+
+    return {
+        "result": result,
+        "usage": {
+            "prompt_tokens": delta_prompt,
+            "completion_tokens": delta_completion,
+            "total_tokens": delta_total
+        },
+        "error": None
+    }

package/src/exceptions.py

@@ -0,0 +1,75 @@
+"""Custom exception hierarchy for vmCode."""
+
+class VmCodeError(Exception):
+    """Base exception for all vmCode application errors.
+
+    All custom exceptions should inherit from this class.
+    Provides consistent error handling and allows catching
+    all vmCode-specific errors with a single except clause.
+    """
+    def __init__(self, message: str, *, details: dict = None):
+        """Initialize exception with optional details.
+
+        Args:
+            message: Human-readable error message
+            details: Optional dictionary with additional error context
+        """
+        super().__init__(message)
+        self.details = details or {}
+
+    def __str__(self):
+        base_msg = super().__str__()
+        if self.details:
+            details_str = ", ".join(f"{k}={v}" for k, v in self.details.items())
+            return f"{base_msg} ({details_str})"
+        return base_msg
+
+
+class ConfigurationError(VmCodeError):
+    """Raised when configuration is invalid, missing, or cannot be loaded."""
+    pass
+
+
+class LLMError(VmCodeError):
+    """Raised when LLM API communication fails or returns unexpected data."""
+    pass
+
+
+class LLMConnectionError(LLMError):
+    """Raised when network connection to LLM provider fails."""
+    pass
+
+
+class LLMResponseError(LLMError):
+    """Raised when LLM response is malformed or invalid."""
+    pass
+
+
+class ToolExecutionError(VmCodeError):
+    """Raised when tool execution fails."""
+    pass
+
+
+class CommandExecutionError(ToolExecutionError):
+    """Raised when shell command execution fails."""
+    pass
+
+
+class FileEditError(ToolExecutionError):
+    """Raised when file edit operation fails."""
+    pass
+
+
+class ValidationError(VmCodeError):
+    """Raised when input validation fails."""
+    pass
+
+
+class PathValidationError(ValidationError):
+    """Raised when path validation fails (blocked by gitignore, etc.)."""
+    pass
+
+
+class CommandValidationError(ValidationError):
+    """Raised when command validation fails (dangerous operators, etc.)."""
+    pass

package/src/llm/__init__.py

@@ -0,0 +1 @@
+"""LLM integration layer for vmCode."""