mfcli 0.2.1__py3-none-any.whl

mfcli/utils/configurator.py

@@ -0,0 +1,324 @@
+"""Interactive configuration wizard for mfcli."""
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+from mfcli.utils.directory_manager import app_dirs
+
+
+def get_env_path() -> Path:
+    """Get the path to the .env file."""
+    return app_dirs.env_file_path
+
+
+def read_existing_env() -> dict:
+    """Read existing environment variables from .env file."""
+    env_path = get_env_path()
+    env_vars = {}
+    
+    if env_path.exists():
+        with open(env_path, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#') and '=' in line:
+                    key, value = line.split('=', 1)
+                    env_vars[key.strip()] = value.strip()
+    
+    return env_vars
+
+
+def write_env_file(env_vars: dict) -> None:
+    """Write environment variables to .env file."""
+    env_path = get_env_path()
+    env_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Read the template
+    template_path = Path(__file__).parent.parent / '.env.example'
+    if not template_path.exists():
+        # Fallback: create basic template
+        template_content = []
+        for key in env_vars:
+            template_content.append(f"{key}={env_vars[key]}")
+        content = '\n'.join(template_content)
+    else:
+        with open(template_path, 'r') as f:
+            template_content = f.read()
+        
+        # Replace placeholder values with actual values
+        content = template_content
+        for key, value in env_vars.items():
+            # Replace the placeholder value in the template
+            content = content.replace(f"{key}=your_{key.lower()}_here", f"{key}={value}")
+            content = content.replace(f"{key}=your_{key.replace('_', ' ').lower()}_here", f"{key}={value}")
+            # Handle specific patterns
+            if key == 'google_api_key':
+                content = content.replace(f"{key}=your_google_api_key_here", f"{key}={value}")
+            elif key == 'openai_api_key':
+                content = content.replace(f"{key}=your_openai_api_key_here", f"{key}={value}")
+            elif key == 'llama_cloud_api_key':
+                content = content.replace(f"{key}=your_llamaparse_api_key_here", f"{key}={value}")
+            elif key == 'digikey_client_id':
+                content = content.replace(f"{key}=your_digikey_client_id_here", f"{key}={value}")
+            elif key == 'digikey_client_secret':
+                content = content.replace(f"{key}=your_digikey_client_secret_here", f"{key}={value}")
+    
+    with open(env_path, 'w') as f:
+        f.write(content)
+
+
+def prompt_for_value(
+    key: str,
+    description: str,
+    link: Optional[str] = None,
+    current_value: Optional[str] = None,
+    required: bool = True
+) -> Optional[str]:
+    """Prompt user for a configuration value."""
+    print(f"\n{'='*70}")
+    print(f"  {description}")
+    if link:
+        print(f"  Get your key: {link}")
+    if current_value and current_value != f"your_{key.lower()}_here":
+        print(f"  Current value: {current_value[:20]}..." if len(current_value) > 20 else f"  Current value: {current_value}")
+        prompt = f"  Enter new value (press Enter to keep current): "
+    else:
+        prompt = f"  Enter value{' (required)' if required else ' (optional)'}: "
+    
+    print(f"{'='*70}")
+    
+    value = input(prompt).strip()
+    
+    if not value:
+        if current_value and current_value != f"your_{key.lower()}_here":
+            return current_value
+        elif not required:
+            return None
+        else:
+            print("  ❌ This value is required!")
+            return prompt_for_value(key, description, link, current_value, required)
+    
+    return value
+
+
+def validate_api_key(key_name: str, api_key: str) -> bool:
+    """Validate an API key by making a test request."""
+    print(f"\n  Validating {key_name}...", end=' ')
+    sys.stdout.flush()
+    
+    try:
+        if key_name == "Google API":
+            import google.generativeai as genai
+            genai.configure(api_key=api_key)
+            # Test with a simple list models call
+            list(genai.list_models())
+            print("✅")
+            return True
+        
+        elif key_name == "OpenAI API":
+            from openai import OpenAI
+            client = OpenAI(api_key=api_key)
+            # Test with a simple models list call
+            client.models.list()
+            print("✅")
+            return True
+        
+        elif key_name == "LlamaParse API":
+            import requests
+            headers = {"Authorization": f"Bearer {api_key}"}
+            # LlamaParse doesn't have a simple test endpoint, so we'll just check format
+            if len(api_key) > 20:
+                print("✅ (format check)")
+                return True
+            else:
+                print("❌ Invalid format")
+                return False
+        
+        elif key_name == "DigiKey API":
+            # DigiKey validation would require OAuth flow, so we'll just check format
+            if len(api_key) > 10:
+                print("✅ (format check)")
+                return True
+            else:
+                print("❌ Invalid format")
+                return False
+        
+    except Exception as e:
+        print(f"❌ ({str(e)[:50]}...)")
+        return False
+    
+    return True
+
+
+def run_configuration_wizard() -> None:
+    """Run the interactive configuration wizard."""
+    print("\n" + "="*70)
+    print("  MFCLI CONFIGURATION WIZARD")
+    print("="*70)
+    print("\n  This wizard will help you configure mfcli with your API keys.")
+    print("  You can press Ctrl+C at any time to exit.\n")
+    
+    try:
+        # Read existing configuration
+        existing_env = read_existing_env()
+        new_env = existing_env.copy()
+        
+        # Google API Key
+        value = prompt_for_value(
+            "google_api_key",
+            "Google Gemini API Key",
+            "https://aistudio.google.com/app/apikey",
+            existing_env.get("google_api_key"),
+            required=True
+        )
+        if value:
+            new_env["google_api_key"] = value
+            validate_api_key("Google API", value)
+        
+        # OpenAI API Key
+        value = prompt_for_value(
+            "openai_api_key",
+            "OpenAI API Key (for embeddings)",
+            "https://platform.openai.com/api-keys",
+            existing_env.get("openai_api_key"),
+            required=True
+        )
+        if value:
+            new_env["openai_api_key"] = value
+            validate_api_key("OpenAI API", value)
+        
+        # LlamaParse API Key
+        value = prompt_for_value(
+            "llama_cloud_api_key",
+            "LlamaParse API Key (for PDF parsing)",
+            "https://cloud.llamaindex.ai/",
+            existing_env.get("llama_cloud_api_key"),
+            required=True
+        )
+        if value:
+            new_env["llama_cloud_api_key"] = value
+            validate_api_key("LlamaParse API", value)
+        
+        # DigiKey Client ID
+        value = prompt_for_value(
+            "digikey_client_id",
+            "DigiKey Client ID (for datasheet downloads)",
+            "https://developer.digikey.com/",
+            existing_env.get("digikey_client_id"),
+            required=True
+        )
+        if value:
+            new_env["digikey_client_id"] = value
+            validate_api_key("DigiKey API", value)
+        
+        # DigiKey Client Secret
+        value = prompt_for_value(
+            "digikey_client_secret",
+            "DigiKey Client Secret",
+            None,
+            existing_env.get("digikey_client_secret"),
+            required=True
+        )
+        if value:
+            new_env["digikey_client_secret"] = value
+        
+        # Embedding configuration
+        print("\n" + "="*70)
+        print("  Vector Database Configuration")
+        print("="*70)
+        print("  Using default values:")
+        print("  - Chunk size: 1000")
+        print("  - Chunk overlap: 200")
+        print("  - Embedding model: text-embedding-3-small")
+        print("  - Embedding dimensions: 1536")
+        
+        change_defaults = input("\n  Change these defaults? (y/N): ").strip().lower()
+        
+        if change_defaults == 'y':
+            value = input("  Chunk size [1000]: ").strip()
+            new_env["chunk_size"] = value if value else "1000"
+            
+            value = input("  Chunk overlap [200]: ").strip()
+            new_env["chunk_overlap"] = value if value else "200"
+            
+            value = input("  Embedding model [text-embedding-3-small]: ").strip()
+            new_env["embedding_model"] = value if value else "text-embedding-3-small"
+            
+            value = input("  Embedding dimensions [1536]: ").strip()
+            new_env["embedding_dimensions"] = value if value else "1536"
+        else:
+            new_env["chunk_size"] = existing_env.get("chunk_size", "1000")
+            new_env["chunk_overlap"] = existing_env.get("chunk_overlap", "200")
+            new_env["embedding_model"] = existing_env.get("embedding_model", "text-embedding-3-small")
+            new_env["embedding_dimensions"] = existing_env.get("embedding_dimensions", "1536")
+        
+        # Write configuration
+        write_env_file(new_env)
+        
+        env_path = get_env_path()
+        print("\n" + "="*70)
+        print("  ✅ Configuration saved successfully!")
+        print(f"  Location: {env_path}")
+        print("="*70)
+        print("\n  Next steps:")
+        print("  1. Run 'mfcli init' in your hardware project directory")
+        print("  2. Run 'mfcli run' to process your documents")
+        print("  3. (Optional) Run 'mfcli setup-mcp' to configure MCP server")
+        print("\n")
+        
+    except KeyboardInterrupt:
+        print("\n\n  ⚠️  Configuration cancelled.")
+        sys.exit(0)
+
+
+def check_configuration() -> None:
+    """Check and validate existing configuration."""
+    print("\n" + "="*70)
+    print("  CONFIGURATION CHECK")
+    print("="*70)
+    
+    env_path = get_env_path()
+    
+    if not env_path.exists():
+        print(f"\n  ❌ Configuration file not found: {env_path}")
+        print("\n  Run 'mfcli configure' to create your configuration.")
+        return
+    
+    print(f"\n  Configuration file: {env_path}")
+    
+    env_vars = read_existing_env()
+    
+    required_keys = [
+        ("google_api_key", "Google Gemini API"),
+        ("openai_api_key", "OpenAI API"),
+        ("llama_cloud_api_key", "LlamaParse API"),
+        ("digikey_client_id", "DigiKey Client ID"),
+        ("digikey_client_secret", "DigiKey Client Secret"),
+    ]
+    
+    print("\n  Checking configuration:")
+    all_valid = True
+    
+    for key, name in required_keys:
+        value = env_vars.get(key)
+        if not value or value.startswith("your_"):
+            print(f"    ❌ {name}: Not configured")
+            all_valid = False
+        else:
+            masked_value = value[:8] + "..." if len(value) > 8 else value
+            print(f"    ✅ {name}: {masked_value}")
+    
+    print("\n  Vector database configuration:")
+    print(f"    - Chunk size: {env_vars.get('chunk_size', 'Not set')}")
+    print(f"    - Chunk overlap: {env_vars.get('chunk_overlap', 'Not set')}")
+    print(f"    - Embedding model: {env_vars.get('embedding_model', 'Not set')}")
+    print(f"    - Embedding dimensions: {env_vars.get('embedding_dimensions', 'Not set')}")
+    
+    if all_valid:
+        print("\n  ✅ All required configuration values are set!")
+        print("\n  To validate API keys, run: mfcli doctor")
+    else:
+        print("\n  ⚠️  Some configuration values are missing.")
+        print("  Run 'mfcli configure' to complete your configuration.")
+    
+    print("="*70 + "\n")

mfcli/utils/data_cleaner.py

@@ -0,0 +1,114 @@
+import os.path
+import shutil
+import sys
+from pathlib import Path
+from textwrap import dedent
+from typing import List
+
+from mfcli.client.chroma_db import ChromaClient
+from mfcli.models.datasheet import Datasheet
+from mfcli.models.project import Project
+from mfcli.utils.config import get_config
+from mfcli.utils.directory_manager import app_dirs, init_directory_structure
+from mfcli.utils.logger import get_logger, setup_logging
+from mfcli.utils.orm import Session
+from mfcli.utils.query_service import QueryService
+
+logger = get_logger(__name__)
+
+warning_message = dedent(
+    """
+    
+    WARNING: This will permanently delete all mfcli data, including datasheets, cheat sheets, and project data. 
+    Should we proceed? (Y/n):
+    
+    """
+)
+
+
+class DataCleaner:
+    def __init__(self, db: Session):
+        self._db = db
+        self._query_service = QueryService(db)
+        self._config = get_config()
+
+    @staticmethod
+    def _remove_dir(dir_path: Path):
+        if not os.path.isdir(dir_path):
+            logger.warning(f"Directory does not exist: {dir_path}")
+            return
+        try:
+            shutil.rmtree(dir_path)
+        except Exception as e:
+            logger.exception(e)
+            logger.error(f"Error deleting directory: {dir_path}")
+
+    @staticmethod
+    def _remove_file(file_path: Path):
+        if not os.path.isfile(file_path):
+            logger.debug(f"File does not exist: {file_path}")
+            return
+        try:
+            os.remove(file_path)
+            logger.debug(f"Removed file: {file_path}")
+        except Exception as e:
+            logger.exception(e)
+            logger.error(f"Error deleting file: {file_path}")
+
+    def clean(self):
+        logger.info("Cleaning mfcli data")
+        
+        # Clear all datasheet entries from the database
+        datasheets: List[Datasheet] = self._query_service.query_all(Datasheet)
+        if datasheets:
+            logger.debug(f"Deleting {len(datasheets)} datasheet entries from database")
+            for datasheet in datasheets:
+                self._db.delete(datasheet)
+            self._db.commit()
+            logger.info(f"Deleted {len(datasheets)} datasheet entries")
+        
+        projects: List[Project] = self._query_service.query_all(Project)
+        for project in projects:
+            init_directory_structure(project.repo_dir)
+            config_dir = Path(project.repo_dir) / ".multifactor"
+            chroma_db = ChromaClient(project.index_id)
+            chroma_db.delete_collection()
+            
+            # Remove config files
+            if app_dirs.config_file_path:
+                logger.debug(f"Removing config file: {app_dirs.config_file_path}")
+                self._remove_file(app_dirs.config_file_path)
+            if app_dirs.file_docket_path:
+                logger.debug(f"Removing file docket: {app_dirs.file_docket_path}")
+                self._remove_file(app_dirs.file_docket_path)
+            
+            for dir_path in [
+                config_dir,
+                app_dirs.agent_instructions_dir,
+                app_dirs.data_sheets_dir,
+                app_dirs.fw_tasks_dir,
+                app_dirs.generated_files_dir,
+                app_dirs.reqs_dir,
+                app_dirs.cheat_sheets_dir,
+                app_dirs.pdf_parts_dir
+            ]:
+                logger.debug(f"Removing directory: {dir_path}")
+                self._remove_dir(dir_path)
+            self._db.delete(project)
+            self._db.commit()
+        logger.info("All mfcli data has been cleaned")
+
+
+def run_data_cleaner():
+    with Session() as db:
+        DataCleaner(db).clean()
+
+
+def clean_app_data(user_accepted: bool = False):
+    setup_logging()
+    if not user_accepted:
+        user_input = input(warning_message)
+        if not user_input.strip() == 'Y':
+            logger.debug("User cancelled")
+            sys.exit()
+    run_data_cleaner()