mfcli 0.2.0__py3-none-any.whl

mfcli/utils/kb_remover.py

@@ -0,0 +1,173 @@
+import json
+from pathlib import Path
+from typing import List
+from mfcli.client.chroma_db import get_chromadb_client_for_project_name
+from mfcli.models.file_docket import FileDocket
+from mfcli.utils.directory_manager import app_dirs
+from mfcli.utils.logger import get_logger
+from mfcli.utils.orm import Session
+
+logger = get_logger(__name__)
+
+
+def _remove_from_file_docket(matching_files: set) -> int:
+    """
+    Remove files from the file_docket.json based on file names.
+    
+    Args:
+        matching_files: Set of file names to remove
+        
+    Returns:
+        Number of entries removed from docket
+    """
+    if not app_dirs.file_docket_path or not app_dirs.file_docket_path.exists():
+        logger.warning("file_docket.json not found, skipping docket removal")
+        return 0
+    
+    try:
+        # Load existing file docket
+        docket = FileDocket()
+        docket.load_from_json(app_dirs.file_docket_path)
+        
+        # Track how many entries we remove
+        removed_count = 0
+        
+        # Find and remove matching entries
+        entries_to_remove = []
+        for entry in docket._docket.entries:
+            if entry.name in matching_files:
+                entries_to_remove.append(entry)
+        
+        for entry in entries_to_remove:
+            docket.remove(entry)
+            removed_count += 1
+            logger.debug(f"Removed from docket: {entry.name}")
+        
+        # Save updated docket back to file
+        if removed_count > 0:
+            json_data = json.dumps(docket.get_entries(), indent=2)
+            with open(app_dirs.file_docket_path, "w") as f:
+                f.write(json_data)
+            logger.info(f"Updated file_docket.json, removed {removed_count} entries")
+        
+        return removed_count
+        
+    except Exception as e:
+        logger.error(f"Failed to remove files from file_docket: {e}")
+        logger.exception(e)
+        return 0
+
+
+def remove_files_from_kb(project_name: str, filename_pattern: str, confirm: bool = True) -> int:
+    """
+    Remove files from the ChromaDB knowledge base that match the given filename pattern.
+    
+    Args:
+        project_name: Name of the project
+        filename_pattern: Full or partial filename to match (case-insensitive)
+        confirm: If True, ask for confirmation before deleting
+        
+    Returns:
+        Number of chunks deleted
+    """
+    try:
+        with Session() as db:
+            chroma_client = get_chromadb_client_for_project_name(db, project_name)
+        
+        # Get all documents from the collection
+        collection = chroma_client._collection
+        results = collection.get()
+        
+        if not results or not results.get('metadatas'):
+            logger.info("No files found in the knowledge base")
+            print("No files found in the knowledge base.")
+            return 0
+        
+        # Find matching file chunks
+        matching_ids: List[str] = []
+        matching_files: set = set()
+        
+        for idx, metadata in enumerate(results['metadatas']):
+            if metadata:
+                file_name = metadata.get('file_name', '')
+                # Case-insensitive partial match
+                if filename_pattern.lower() in file_name.lower():
+                    matching_ids.append(results['ids'][idx])
+                    matching_files.add(file_name)
+        
+        if not matching_ids:
+            print(f"\nNo files matching '{filename_pattern}' found in the knowledge base.")
+            return 0
+        
+        # Display matching files
+        print(f"\nFound {len(matching_files)} file(s) matching '{filename_pattern}':")
+        for file_name in sorted(matching_files):
+            print(f"  • {file_name}")
+        print(f"\nTotal chunks to delete: {len(matching_ids)}")
+        
+        # Confirm deletion
+        if confirm:
+            response = input("\nAre you sure you want to delete these files? (yes/no): ")
+            if response.lower() not in ['yes', 'y']:
+                print("Deletion cancelled.")
+                return 0
+        
+        # Delete the chunks from ChromaDB
+        collection.delete(ids=matching_ids)
+        
+        # Remove files from file_docket
+        removed_from_docket = _remove_from_file_docket(matching_files)
+        
+        print(f"\nSuccessfully deleted {len(matching_ids)} chunks from {len(matching_files)} file(s).")
+        if removed_from_docket > 0:
+            print(f"Removed {removed_from_docket} file(s) from file_docket.json")
+        logger.info(f"Deleted {len(matching_ids)} chunks from {len(matching_files)} files matching '{filename_pattern}'")
+        logger.info(f"Removed {removed_from_docket} entries from file_docket")
+        
+        return len(matching_ids)
+        
+    except Exception as e:
+        logger.error(f"Failed to remove files from knowledge base for project: {project_name}")
+        logger.exception(e)
+        print(f"\nError: Failed to remove files. Check logs for details.")
+        raise
+
+
+def list_matching_files(project_name: str, filename_pattern: str) -> List[str]:
+    """
+    List files that match the given filename pattern without deleting them.
+    
+    Args:
+        project_name: Name of the project
+        filename_pattern: Full or partial filename to match (case-insensitive)
+        
+    Returns:
+        List of matching filenames
+    """
+    try:
+        with Session() as db:
+            chroma_client = get_chromadb_client_for_project_name(db, project_name)
+        
+        # Get all documents from the collection
+        collection = chroma_client._collection
+        results = collection.get()
+        
+        if not results or not results.get('metadatas'):
+            return []
+        
+        # Find matching files
+        matching_files: set = set()
+        
+        for metadata in results['metadatas']:
+            if metadata:
+                file_name = metadata.get('file_name', '')
+                # Case-insensitive partial match
+                if filename_pattern.lower() in file_name.lower():
+                    matching_files.add(file_name)
+        
+        return sorted(list(matching_files))
+        
+    except Exception as e:
+        logger.error(f"Failed to list matching files for project: {project_name}")
+        logger.exception(e)
+        return []

mfcli/utils/logger.py

@@ -0,0 +1,28 @@
+import logging
+import sys
+
+from mfcli.utils.config import get_config
+
+
+def setup_logging():
+    config = get_config()
+    formatter = logging.Formatter(
+        fmt="%(asctime)s [%(levelname)s] %(name)s:%(funcName)s:%(lineno)d: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(formatter)
+
+    logger = logging.getLogger()
+    logger.setLevel(config.log_level)
+    logger.addHandler(handler)
+    logger.propagate = False
+
+    logging.getLogger("google_genai").setLevel(logging.ERROR)
+    logging.getLogger("httpx").setLevel(logging.ERROR)
+    logging.getLogger("docling").setLevel(logging.ERROR)
+
+
+def get_logger(name=None):
+    return logging.getLogger(name or __name__)

mfcli/utils/mcp_configurator.py

@@ -0,0 +1,311 @@
+"""MCP server auto-configuration for Cline and Claude Code."""
+import json
+import os
+import platform
+import shutil
+import sys
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+
+def get_mcp_config_paths() -> List[Tuple[str, Path]]:
+    """Get potential MCP configuration file paths for different editors."""
+    paths = []
+    system = platform.system()
+    
+    if system == "Windows":
+        appdata = Path(os.environ.get("APPDATA", ""))
+        localappdata = Path(os.environ.get("LOCALAPPDATA", ""))
+        
+        # Cline (VS Code extension)
+        cline_vscode = appdata / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json"
+        if cline_vscode.exists():
+            paths.append(("Cline (VS Code)", cline_vscode))
+        
+        # Windsurf/Cline standalone
+        home = Path.home()
+        cline_standalone = home / ".cline" / "mcp_settings.json"
+        if cline_standalone.exists():
+            paths.append(("Cline (Standalone)", cline_standalone))
+        
+        # Claude Code (if it exists on Windows - need to verify path)
+        # This is a placeholder - actual path may differ
+        claude_code = localappdata / "Claude" / "mcp_settings.json"
+        if claude_code.exists():
+            paths.append(("Claude Code", claude_code))
+    
+    elif system in ["Darwin", "Linux"]:  # macOS or Linux
+        home = Path.home()
+        
+        # Cline (VS Code extension) - macOS
+        if system == "Darwin":
+            cline_vscode = home / "Library" / "Application Support" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json"
+        else:  # Linux
+            cline_vscode = home / ".config" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json"
+        
+        if cline_vscode.exists():
+            paths.append(("Cline (VS Code)", cline_vscode))
+        
+        # Windsurf/Cline standalone
+        cline_standalone = home / ".cline" / "mcp_settings.json"
+        if cline_standalone.exists():
+            paths.append(("Cline (Standalone)", cline_standalone))
+        
+        # Claude Code
+        claude_code = home / ".claude" / "mcp_settings.json"
+        if claude_code.exists():
+            paths.append(("Claude Code", claude_code))
+    
+    return paths
+
+
+def backup_config(config_path: Path) -> Path:
+    """Create a backup of the configuration file."""
+    backup_path = config_path.with_suffix(config_path.suffix + ".backup")
+    shutil.copy2(config_path, backup_path)
+    return backup_path
+
+
+def get_mfcli_mcp_config() -> dict:
+    """Get the mfcli-mcp server configuration."""
+    return {
+        "mfcli-mcp": {
+            "disabled": False,
+            "timeout": 60,
+            "type": "stdio",
+            "command": "mfcli-mcp"
+        }
+    }
+
+
+def update_mcp_config(config_path: Path) -> bool:
+    """Update MCP configuration file with mfcli-mcp server."""
+    try:
+        # Read existing config
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        # Ensure mcpServers key exists
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+        
+        # Check if mfcli-mcp already exists
+        if "mfcli-mcp" in config["mcpServers"]:
+            print(f"    ℹ️  mfcli-mcp already configured in this file")
+            return True
+        
+        # Add mfcli-mcp configuration
+        mfcli_config = get_mfcli_mcp_config()
+        config["mcpServers"].update(mfcli_config)
+        
+        # Create backup
+        backup_path = backup_config(config_path)
+        print(f"    📋 Backup created: {backup_path}")
+        
+        # Write updated config
+        with open(config_path, 'w') as f:
+            json.dump(config, f, indent=2)
+        
+        return True
+    
+    except Exception as e:
+        print(f"    ❌ Error updating config: {e}")
+        return False
+
+
+def create_mcp_config(config_path: Path) -> bool:
+    """Create a new MCP configuration file with mfcli-mcp server."""
+    try:
+        # Ensure parent directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Create new config
+        config = {
+            "mcpServers": get_mfcli_mcp_config()
+        }
+        
+        # Write config
+        with open(config_path, 'w') as f:
+            json.dump(config, f, indent=2)
+        
+        return True
+    
+    except Exception as e:
+        print(f"    ❌ Error creating config: {e}")
+        return False
+
+
+def verify_mfcli_installation() -> bool:
+    """Verify that mfcli-mcp is installed and accessible."""
+    try:
+        # Check if mfcli-mcp is in PATH
+        result = shutil.which("mfcli-mcp")
+        if result:
+            return True
+        
+        # On Windows, also check Scripts directory
+        if platform.system() == "Windows":
+            scripts_dir = Path(sys.executable).parent / "Scripts"
+            mfcli_mcp = scripts_dir / "mfcli-mcp.exe"
+            if mfcli_mcp.exists():
+                return True
+        
+        return False
+    
+    except Exception:
+        return False
+
+
+def test_mcp_server() -> bool:
+    """Test if MCP server can be started."""
+    print("  Testing MCP server...", end=' ')
+    sys.stdout.flush()
+    
+    try:
+        import subprocess
+        # Try to run mfcli-mcp with a timeout
+        result = subprocess.run(
+            ["mfcli-mcp"],
+            capture_output=True,
+            timeout=5,
+            text=True
+        )
+        # If it starts without error, that's good enough
+        print("✅")
+        return True
+    except subprocess.TimeoutExpired:
+        # Timeout is actually OK - it means the server started
+        print("✅")
+        return True
+    except FileNotFoundError:
+        print("❌ mfcli-mcp command not found")
+        return False
+    except Exception as e:
+        print(f"❌ {str(e)[:50]}")
+        return False
+
+
+def setup_mcp_servers() -> None:
+    """Auto-configure MCP servers for detected editors."""
+    print("\n" + "="*70)
+    print("  MCP SERVER AUTO-CONFIGURATION")
+    print("="*70)
+    print("\n  Detecting installed AI coding assistants...")
+    
+    # Verify mfcli installation
+    if not verify_mfcli_installation():
+        print("\n  ❌ mfcli-mcp command not found!")
+        print("\n  Please ensure mfcli is installed with:")
+        print("    pipx install mfcli")
+        print("\n  Or if installing from source:")
+        print("    pip install .")
+        print("="*70 + "\n")
+        return
+    
+    # Get configuration paths
+    config_paths = get_mcp_config_paths()
+    
+    if not config_paths:
+        print("\n  ℹ️  No AI coding assistants detected.")
+        print("\n  Supported editors:")
+        print("    - Cline (VS Code extension)")
+        print("    - Cline (Standalone)")
+        print("    - Claude Code")
+        print("\n  If you have one of these installed, the configuration file may")
+        print("  not exist yet. You can create it manually at:")
+        
+        system = platform.system()
+        if system == "Windows":
+            print("\n  Cline (VS Code):")
+            print("    %APPDATA%\\Code\\User\\globalStorage\\saoudrizwan.claude-dev\\settings\\cline_mcp_settings.json")
+            print("\n  Cline (Standalone):")
+            print("    %USERPROFILE%\\.cline\\mcp_settings.json")
+        else:
+            print("\n  Cline (VS Code):")
+            if system == "Darwin":
+                print("    ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json")
+            else:
+                print("    ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json")
+            print("\n  Cline (Standalone):")
+            print("    ~/.cline/mcp_settings.json")
+            print("\n  Claude Code:")
+            print("    ~/.claude/mcp_settings.json")
+        
+        print("\n  Then run this command again.")
+        print("="*70 + "\n")
+        return
+    
+    print(f"\n  Found {len(config_paths)} configuration file(s):\n")
+    
+    success_count = 0
+    for name, path in config_paths:
+        print(f"  📝 {name}")
+        print(f"     {path}")
+        
+        if update_mcp_config(path):
+            print(f"     ✅ Successfully configured!\n")
+            success_count += 1
+        else:
+            print(f"     ❌ Configuration failed\n")
+    
+    if success_count > 0:
+        print("="*70)
+        print(f"  ✅ Successfully configured {success_count} editor(s)!")
+        print("="*70)
+        print("\n  Next steps:")
+        print("  1. Restart your editor (VS Code, Cline, etc.)")
+        print("  2. The mfcli-mcp server should now be available")
+        print("  3. Try using the 'query_local_rag' tool in your AI assistant")
+        print("\n  To test the MCP server:")
+        print("    mfcli doctor")
+        print("\n")
+    else:
+        print("="*70)
+        print("  ⚠️  No configurations were updated.")
+        print("="*70 + "\n")
+
+
+def get_manual_setup_instructions() -> str:
+    """Get manual MCP setup instructions."""
+    instructions = """
+Manual MCP Setup Instructions
+==============================
+
+If auto-configuration didn't work, you can manually add mfcli-mcp to your
+editor's MCP configuration file.
+
+1. Locate your MCP configuration file:
+
+   Windows (Cline in VS Code):
+   %APPDATA%\\Code\\User\\globalStorage\\saoudrizwan.claude-dev\\settings\\cline_mcp_settings.json
+
+   macOS (Cline in VS Code):
+   ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
+
+   Linux (Cline in VS Code):
+   ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
+
+   Cline Standalone:
+   ~/.cline/mcp_settings.json
+
+   Claude Code:
+   ~/.claude/mcp_settings.json
+
+2. Add the following configuration to the "mcpServers" section:
+
+{
+  "mcpServers": {
+    "mfcli-mcp": {
+      "disabled": false,
+      "timeout": 60,
+      "type": "stdio",
+      "command": "mfcli-mcp"
+    }
+  }
+}
+
+3. Save the file and restart your editor.
+
+4. The mfcli-mcp server should now be available in your AI assistant.
+"""
+    return instructions

mfcli/utils/migrations.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+from mfcli.utils.files import file_access_check
+from mfcli.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def run_migrations():
+    from alembic.config import Config
+    from alembic import command
+
+    config_file_path = Path(__file__).parent.parent / "alembic.ini"
+    if not file_access_check(config_file_path):
+        raise RuntimeError(f"Could not find Alembic config file path: {config_file_path}")
+
+    alembic_cfg = Config(config_file_path)
+    command.upgrade(alembic_cfg, "head")

mfcli/utils/orm.py

@@ -0,0 +1,43 @@
+from functools import lru_cache
+
+from sqlalchemy import create_engine, event
+from sqlalchemy.orm import sessionmaker, Session as dbSession
+
+from mfcli.models.base import Base
+from mfcli.models.bom import BOM
+
+from mfcli.utils.config import get_config
+from mfcli.utils.directory_manager import app_dirs
+
+config = get_config()
+
+
+@lru_cache
+def get_db_url() -> str:
+    return f"sqlite:///{app_dirs.app_data_dir / "multifactor.db"}"
+
+
+engine = create_engine(
+    get_db_url(),
+    pool_pre_ping=True,
+    pool_recycle=1800,
+    pool_size=10,
+    max_overflow=20,
+    pool_timeout=30
+)
+
+
+@event.listens_for(engine, "connect")
+def enable_sqlite_fk(dbapi_conn, conn_record):
+    cursor = dbapi_conn.cursor()
+    cursor.execute("PRAGMA foreign_keys=ON;")
+    cursor.close()
+
+
+Session = sessionmaker(bind=engine)
+session = dbSession(engine)
+
+
+def create_orm():
+    engine.connect()
+    Base.metadata.create_all(engine)

mfcli/utils/pdf_splitter.py

@@ -0,0 +1,63 @@
+import tempfile
+from pathlib import Path
+from uuid import uuid4
+
+import pikepdf
+from io import BytesIO
+
+from mfcli.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class PDFSplitter:
+    def __init__(self, file_name: str, content: bytes):
+        self._name = file_name
+        self._content = content
+
+    @staticmethod
+    def _head_page_limit(total_pages: int) -> int:
+        if total_pages <= 30:
+            return 10
+        elif total_pages <= 100:
+            return 20
+        else:
+            return 30
+
+    def _open_pdf(self) -> pikepdf.Pdf:
+        return pikepdf.open(BytesIO(self._content))
+
+    def split_pdf_head(self) -> Path:
+        with self._open_pdf() as src:
+            total_pages = len(src.pages)
+            page_limit = self._head_page_limit(total_pages)
+
+            dst = pikepdf.Pdf.new()
+            dst.pages.extend(src.pages[:page_limit])
+
+            output_path = Path(tempfile.mktemp(suffix=".pdf"))
+            dst.save(output_path)
+
+            return output_path
+
+    def extract_range(
+            self,
+            start_page: int,
+            end_page: int,
+            output_folder: Path,
+    ) -> Path:
+        logger.debug(f"Splitting PDF: {self._name}")
+
+        output_folder.mkdir(parents=True, exist_ok=True)
+
+        with self._open_pdf() as src:
+            dst = pikepdf.Pdf.new()
+            dst.pages.extend(src.pages[start_page:end_page + 1])
+
+            output_path = output_folder / f"{uuid4().hex}.pdf"
+            dst.save(output_path)
+
+        logger.debug(f"Output PDF part to: {output_path}")
+        logger.debug(f"PDF splitter finished: {self._name}")
+
+        return output_path

mfcli/utils/query_service.py

@@ -0,0 +1,22 @@
+from typing import Type, List, Any
+
+from mfcli.models.base import Base
+from mfcli.utils.orm import Session
+
+
+class QueryService:
+    def __init__(self, db: Session):
+        self._db = db
+
+    def query_all(
+            self,
+            entity_type: Type[Base],
+            filters: List[Any] | None = None,
+            order_by: Any | None = None
+    ) -> List[Base]:
+        query = self._db.query(entity_type)
+        if filters:
+            query = query.filter(filters)
+        if order_by:
+            query = query.order_by(order_by)
+        return query.all()