minion-code 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

minion_code/utils/history.py

@@ -0,0 +1,114 @@
+"""History management utilities for minion-code.
+
+This module provides command history functionality similar to the TypeScript
+history.ts file, adapted for Python and the minion-code project structure.
+"""
+
+from typing import List
+from .config import get_current_project_config, save_current_project_config
+
+MAX_HISTORY_ITEMS = 100
+
+
+def get_history() -> List[str]:
+    """Get command history for the current project.
+
+    Returns:
+        List of command history strings, with most recent first.
+    """
+    project_config = get_current_project_config()
+    return project_config.history or []
+
+
+def add_to_history(command: str) -> None:
+    """Add a command to the history.
+
+    Args:
+        command: The command string to add to history.
+
+    Note:
+        - Commands are added to the beginning of the history list
+        - Duplicate consecutive commands are not added
+        - History is limited to MAX_HISTORY_ITEMS entries
+    """
+    if not command or not command.strip():
+        return
+
+    command = command.strip()
+    project_config = get_current_project_config()
+    history = project_config.history or []
+
+    # Don't add if it's the same as the most recent command
+    if history and history[0] == command:
+        return
+
+    # Add to beginning and limit to MAX_HISTORY_ITEMS
+    history.insert(0, command)
+    project_config.history = history[:MAX_HISTORY_ITEMS]
+
+    save_current_project_config(project_config)
+
+
+def clear_history() -> None:
+    """Clear all command history for the current project."""
+    project_config = get_current_project_config()
+    project_config.history = []
+    save_current_project_config(project_config)
+
+
+def remove_from_history(command: str) -> bool:
+    """Remove a specific command from history.
+
+    Args:
+        command: The command string to remove from history.
+
+    Returns:
+        True if the command was found and removed, False otherwise.
+    """
+    if not command or not command.strip():
+        return False
+
+    command = command.strip()
+    project_config = get_current_project_config()
+    history = project_config.history or []
+
+    if command in history:
+        history.remove(command)
+        project_config.history = history
+        save_current_project_config(project_config)
+        return True
+
+    return False
+
+
+def get_history_item(index: int) -> str:
+    """Get a specific history item by index.
+
+    Args:
+        index: The index of the history item (0 is most recent).
+
+    Returns:
+        The command string at the specified index, or empty string if not found.
+    """
+    history = get_history()
+    if 0 <= index < len(history):
+        return history[index]
+    return ""
+
+
+def search_history(query: str) -> List[str]:
+    """Search history for commands containing the query string.
+
+    Args:
+        query: The search query string.
+
+    Returns:
+        List of matching commands, with most recent first.
+    """
+    if not query or not query.strip():
+        return []
+
+    query = query.strip().lower()
+    history = get_history()
+
+    return [cmd for cmd in history if query in cmd.lower()]

minion_code/utils/logs.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from loguru import logger as _logger
+from minion.const import MINION_ROOT
+
+_print_level = "INFO"
+
+
+def define_log_level(print_level="INFO", logfile_level="DEBUG", name: str = None):
+    """Adjust the log level to above level"""
+    global _print_level
+    _print_level = print_level
+
+    current_date = datetime.now()
+    formatted_date = current_date.strftime("%Y%m%d")
+    log_name = (
+        f"{name}_{formatted_date}" if name else formatted_date
+    )  # name a log with prefix name
+
+    _logger.remove()
+    _logger.add(sys.stdout, level=print_level)
+    _logger.add(MINION_ROOT / f"logs/{log_name}.txt", level=logfile_level)
+    return _logger
+
+
+def setup_tui_logging():
+    """Setup logging for TUI mode - removes console output to prevent UI interference"""
+    global _print_level
+
+    # Remove all existing handlers
+    _logger.remove()
+
+    # Only add file logging for TUI mode
+    current_date = datetime.now()
+    formatted_date = current_date.strftime("%Y%m%d")
+    log_name = f"{formatted_date}"
+
+    # Ensure logs directory exists
+    logs_dir = MINION_ROOT / "logs"
+    logs_dir.mkdir(exist_ok=True)
+
+    _logger.add(logs_dir / f"{log_name}.txt", level="DEBUG")
+    _print_level = "DEBUG"  # Set to DEBUG for file logging
+
+    return _logger
+
+
+logger = define_log_level()

minion_code/utils/mcp_loader.py

@@ -11,12 +11,14 @@ import json
 import logging
 import subprocess
 import asyncio
+import os
 from pathlib import Path
 from typing import Dict, List, Any, Optional
 from dataclasses import dataclass
 
 try:
     from minion.tools.mcp.mcp_toolset import MCPToolset, StdioServerParameters
+
     MCP_AVAILABLE = True
 except ImportError:
     MCP_AVAILABLE = False
@@ -26,16 +28,95 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 
+def find_mcp_config(project_dir: Optional[Path] = None) -> Optional[Path]:
+    """
+    Auto-discover MCP configuration file.
+
+    Searches in the following order (first found wins):
+
+    Project scope (current working directory or specified project_dir):
+    1. .mcp.json
+    2. .claude/mcp.json
+    3. .minion/mcp.json
+
+    User scope (home directory):
+    4. ~/.claude-code/mcp.json
+    5. ~/.minion-code/mcp.json
+    6. ~/.config/minion-code/mcp.json (XDG standard)
+
+    Args:
+        project_dir: Project directory to search in (defaults to cwd)
+
+    Returns:
+        Path to config file if found, None otherwise
+    """
+    # Project scope locations
+    project_root = project_dir or Path.cwd()
+    project_locations = [
+        project_root / ".mcp.json",
+        project_root / ".claude" / "mcp.json",
+        project_root / ".minion" / "mcp.json",
+    ]
+
+    # User scope locations
+    home = Path.home()
+    user_locations = [
+        home / ".claude-code" / "mcp.json",
+        home / ".minion-code" / "mcp.json",
+        home / ".config" / "minion-code" / "mcp.json",
+    ]
+
+    # Search project scope first
+    for config_path in project_locations:
+        if config_path.exists():
+            logger.info(f"Found MCP config at project scope: {config_path}")
+            return config_path
+
+    # Then search user scope
+    for config_path in user_locations:
+        if config_path.exists():
+            logger.info(f"Found MCP config at user scope: {config_path}")
+            return config_path
+
+    logger.debug("No MCP config file found in any standard location")
+    return None
+
+
+def get_mcp_config_locations() -> Dict[str, List[Path]]:
+    """
+    Get all standard MCP config file locations.
+
+    Returns:
+        Dictionary with 'project' and 'user' scope locations
+    """
+    project_root = Path.cwd()
+    home = Path.home()
+
+    return {
+        "project": [
+            project_root / ".mcp.json",
+            project_root / ".claude" / "mcp.json",
+            project_root / ".minion" / "mcp.json",
+        ],
+        "user": [
+            home / ".claude-code" / "mcp.json",
+            home / ".minion-code" / "mcp.json",
+            home / ".config" / "minion-code" / "mcp.json",
+        ],
+    }
+
+
 @dataclass
 class MCPServerConfig:
     """Configuration for an MCP server."""
+
     name: str
     command: str
     args: List[str]
     env: Optional[Dict[str, str]] = None
     disabled: bool = False
     auto_approve: List[str] = None
-    
+
     def __post_init__(self):
         if self.auto_approve is None:
             self.auto_approve = []
@@ -43,154 +124,171 @@ class MCPServerConfig:
 
 class MCPToolsLoader:
     """Loader for MCP tools from configuration files."""
-    
-    def __init__(self, config_path: Optional[Path] = None):
+
+    def __init__(self, config_path: Optional[Path] = None, auto_discover: bool = True):
         """
         Initialize MCP tools loader.
-        
+
         Args:
-            config_path: Path to MCP configuration file
+            config_path: Path to MCP configuration file. If None and auto_discover=True,
+                        will search standard locations.
+            auto_discover: If True and config_path is None, automatically search for
+                          config in standard locations (.mcp.json, .claude/, .minion/, etc.)
         """
-        self.config_path = config_path
+        if config_path:
+            self.config_path = config_path
+        elif auto_discover:
+            self.config_path = find_mcp_config()
+        else:
+            self.config_path = None
+
         self.servers: Dict[str, MCPServerConfig] = {}
         self.loaded_tools = []
         self.toolsets: List[Any] = []  # Store MCPToolset instances for cleanup
-    
-    def load_config(self, config_path: Optional[Path] = None) -> Dict[str, MCPServerConfig]:
+
+    def load_config(
+        self, config_path: Optional[Path] = None
+    ) -> Dict[str, MCPServerConfig]:
         """
         Load MCP configuration from JSON file.
-        
+
         Args:
             config_path: Path to configuration file
-            
+
         Returns:
             Dictionary of server configurations
         """
         if config_path:
             self.config_path = config_path
-        
+
         if not self.config_path or not self.config_path.exists():
             logger.warning(f"MCP config file not found: {self.config_path}")
             return {}
-        
+
         try:
-            with open(self.config_path, 'r', encoding='utf-8') as f:
+            with open(self.config_path, "r", encoding="utf-8") as f:
                 config_data = json.load(f)
-            
-            servers_config = config_data.get('mcpServers', {})
-            
+
+            servers_config = config_data.get("mcpServers", {})
+
             for server_name, server_data in servers_config.items():
                 self.servers[server_name] = MCPServerConfig(
                     name=server_name,
-                    command=server_data.get('command', ''),
-                    args=server_data.get('args', []),
-                    env=server_data.get('env', {}),
-                    disabled=server_data.get('disabled', False),
-                    auto_approve=server_data.get('autoApprove', [])
+                    command=server_data.get("command", ""),
+                    args=server_data.get("args", []),
+                    env=server_data.get("env", {}),
+                    disabled=server_data.get("disabled", False),
+                    auto_approve=server_data.get("autoApprove", []),
                 )
-            
+
             logger.info(f"Loaded {len(self.servers)} MCP server configurations")
             return self.servers
-            
+
         except Exception as e:
             logger.error(f"Failed to load MCP config from {self.config_path}: {e}")
             return {}
-    
+
     async def load_tools_from_server(self, server_config: MCPServerConfig) -> List[Any]:
         """
         Load tools from an MCP server.
-        
+
         Args:
             server_config: Server configuration
-            
+
         Returns:
             List of loaded tools
         """
         if server_config.disabled:
             logger.info(f"Skipping disabled MCP server: {server_config.name}")
             return []
-        
+
         if not MCP_AVAILABLE:
             logger.warning("MCP framework not available, skipping MCP server loading")
             return []
-        
+
         try:
             logger.info(f"Loading tools from MCP server: {server_config.name}")
-            logger.info(f"Command: {server_config.command} {' '.join(server_config.args)}")
-            
+            logger.info(
+                f"Command: {server_config.command} {' '.join(server_config.args)}"
+            )
+
             # Create MCPToolset with StdioServerParameters
             toolset = await MCPToolset.create(
                 connection_params=StdioServerParameters(
                     command=server_config.command,
                     args=server_config.args,
-                    env=server_config.env or {}
+                    env=server_config.env or {},
                 ),
                 name=server_config.name,
-                structured_output=False  # Set to False as requested
+                structured_output=False,  # Set to False as requested
             )
-            
+
             # Store toolset for cleanup
             self.toolsets.append(toolset)
-            
+
             # Get tools from the toolset
-            tools = toolset.tools if hasattr(toolset, 'tools') else []
-            
-            logger.info(f"Successfully loaded {len(tools)} tools from {server_config.name}")
+            tools = toolset.tools if hasattr(toolset, "tools") else []
+
+            logger.info(
+                f"Successfully loaded {len(tools)} tools from {server_config.name}"
+            )
             return tools
-            
+
         except Exception as e:
-            logger.error(f"Failed to load tools from MCP server {server_config.name}: {e}")
+            logger.error(
+                f"Failed to load tools from MCP server {server_config.name}: {e}"
+            )
             return []
-    
+
     async def load_all_tools(self) -> List[Any]:
         """
         Load tools from all configured MCP servers.
-        
+
         Returns:
             List of all loaded MCP tools
         """
         all_tools = []
-        
+
         for server_name, server_config in self.servers.items():
             if not server_config.disabled:
                 tools = await self.load_tools_from_server(server_config)
                 all_tools.extend(tools)
                 logger.info(f"Loaded {len(tools)} tools from {server_name}")
-        
+
         self.loaded_tools = all_tools
         logger.info(f"Total MCP tools loaded: {len(all_tools)}")
         return all_tools
-    
+
     def get_server_info(self) -> Dict[str, Dict[str, Any]]:
         """
         Get information about configured servers.
-        
+
         Returns:
             Dictionary with server information
         """
         info = {}
         for name, config in self.servers.items():
             info[name] = {
-                'command': config.command,
-                'args': config.args,
-                'disabled': config.disabled,
-                'auto_approve_count': len(config.auto_approve)
+                "command": config.command,
+                "args": config.args,
+                "disabled": config.disabled,
+                "auto_approve_count": len(config.auto_approve),
             }
         return info
-    
+
     async def close(self):
         """
         Close all MCP toolsets and clean up resources.
         """
         logger.info(f"Closing {len(self.toolsets)} MCP toolsets...")
-        
+
         for toolset in self.toolsets:
             try:
                 await toolset.close()
                 logger.debug(f"Closed toolset: {getattr(toolset, 'name', 'unknown')}")
             except Exception as e:
                 logger.error(f"Error closing toolset: {e}")
-        
+
         self.toolsets.clear()
         logger.info("All MCP toolsets closed")
 
@@ -199,13 +297,13 @@ class MCPToolsLoader:
 async def load_mcp_tools(config_path: Path) -> List[Any]:
     """
     Convenience function to load MCP tools from a configuration file.
-    
+
     Args:
         config_path: Path to MCP configuration file
-        
+
     Returns:
         List of loaded MCP tools
     """
     loader = MCPToolsLoader(config_path)
     loader.load_config()
-    return await loader.load_all_tools()
+    return await loader.load_all_tools()