google-drive-forge 0.2.0__py3-none-any.whl

google_drive_forge/__init__.py

@@ -0,0 +1,9 @@
+from .intelligent_client import IntelligentDriveClient
+from .executor import ScriptExecutor
+from .skill_loader import SkillLoader
+from .client import DriveClient
+
+# Alias for branding
+ForgeClient = IntelligentDriveClient
+
+__all__ = ["IntelligentDriveClient", "ForgeClient", "ScriptExecutor", "SkillLoader", "DriveClient"]

google_drive_forge/__main__.py

@@ -0,0 +1,59 @@
+import logging
+import os
+import sys
+from mcp.server.fastmcp import FastMCP
+from .intelligent_client import IntelligentDriveClient
+from .tools import register_tools, register_intelligent_tools
+from .resources import register_resources
+from .executor import ScriptExecutor
+from .skill_loader import SkillLoader
+from .audit import AuditLogger
+
+# Configure logging
+logging.basicConfig()
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+# Initialize FastMCP Server
+mcp = FastMCP("google-drive-forge")
+
+# Setup Paths from Environment or Defaults
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(BASE_DIR))
+
+SKILLS_DIR = os.getenv("GOOGLE_DRIVE_SKILLS_DIR", os.path.join(BASE_DIR, "skills"))
+# Default to current python if no specific venv provided or found
+DEFAULT_VENV = os.path.join(os.path.dirname(BASE_DIR), "antigravity-env")
+PYTHON_EXE = os.getenv("GOOGLE_DRIVE_PYTHON_PATH")
+
+if not PYTHON_EXE:
+    if os.path.exists(DEFAULT_VENV):
+        PYTHON_EXE = DEFAULT_VENV
+    else:
+        PYTHON_EXE = sys.executable
+
+AUDIT_LOG = os.getenv("GOOGLE_DRIVE_AUDIT_LOG", os.path.join(PROJECT_ROOT, "docs/research/intelligent_audit.log"))
+
+try:
+    # Initialize Core Components
+    audit = AuditLogger(AUDIT_LOG)
+    client = IntelligentDriveClient(audit=audit)
+    executor = ScriptExecutor(PYTHON_EXE, SKILLS_DIR)
+    loader = SkillLoader(SKILLS_DIR)
+    
+    # Register Components
+    register_tools(mcp, client)
+    register_resources(mcp, client)
+    register_intelligent_tools(mcp, client, executor, loader, audit)
+    
+except Exception as e:
+    logger.error(f"Failed to initialize server components: {e}")
+    @mcp.tool()
+    def status() -> str:
+        return f"Server failed to initialize: {str(e)}. Please check setup."
+
+def main():
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

google_drive_forge/audit.py

@@ -0,0 +1,37 @@
+import os
+import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+class AuditLogger:
+    def __init__(self, audit_log_path: str):
+        self.audit_log_path = audit_log_path
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(audit_log_path), exist_ok=True)
+
+    def log_event(self, event_type: str, details: str, status: str = "INFO"):
+        """
+        Logs an intelligent operation event.
+        """
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        log_entry = f"[{timestamp}] [{status}] [{event_type}] {details}\n"
+        
+        try:
+            with open(self.audit_log_path, "a") as f:
+                f.write(log_entry)
+        except Exception as e:
+            logger.error(f"Failed to write to audit log: {e}")
+
+    def log_recovery(self, original_id: str, recovered_name: str, success: bool):
+        """
+        Specific log for autonomous recovery events.
+        """
+        status = "SUCCESS" if success else "FAILURE"
+        self.log_event("RECOVERY", f"Target ID: {original_id} -> Found: {recovered_name}", status)
+
+    def log_skill_creation(self, skill_name: str):
+        """
+        Specific log for new skill forging.
+        """
+        self.log_event("SKILL_FORGE", f"New capability created: {skill_name}")

google_drive_forge/auth.py

@@ -0,0 +1,75 @@
+import os
+import json
+import logging
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+
+# Configure logger for this module
+logger = logging.getLogger(__name__)
+
+# Scopes required for the application
+SCOPES = ['https://www.googleapis.com/auth/drive']
+
+# Base directory for relative paths (assumes this file is in src/, so go up one level)
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+TOKEN_PATH = os.path.join(BASE_DIR, 'token.json')
+CREDENTIALS_PATH = os.path.join(BASE_DIR, 'credentials.json')
+
+def get_credentials() -> Credentials:
+    """
+    Retrieves OAuth2 credentials.
+    Refreshes expired tokens if possible, or triggers a new login flow.
+    """
+    creds = None
+    
+    # 1. Try to load existing token
+    if os.path.exists(TOKEN_PATH):
+        try:
+            creds = Credentials.from_authorized_user_file(TOKEN_PATH, SCOPES)
+        except Exception as e:
+            logger.warning(f"Error loading token.json: {e}")
+            # Invalid token file, ignore it
+
+    # 2. If no valid credentials, login or refresh
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            logger.info("Refreshing access token...")
+            try:
+                creds.refresh(Request())
+            except Exception as e:
+                 logger.warning(f"Error refreshing token: {e}. Initiating new login.")
+                 creds = _login_flow()
+        else:
+            logger.info("No valid token found. Initiating login flow...")
+            creds = _login_flow()
+
+        # 3. Save the new/refreshed token
+        with open(TOKEN_PATH, 'w') as token:
+            token.write(creds.to_json())
+            logger.info(f"Token saved to {TOKEN_PATH}")
+
+    return creds
+
+def _login_flow() -> Credentials:
+    """Helper to run the interactive OAuth flow."""
+    if not os.path.exists(CREDENTIALS_PATH):
+        raise FileNotFoundError(
+            f"Credentials file not found at {CREDENTIALS_PATH}. "
+            "Please download it from Google Cloud Console and place it there."
+        )
+
+    flow = InstalledAppFlow.from_client_secrets_file(CREDENTIALS_PATH, SCOPES)
+    
+    # Check for headless environment
+    is_headless = os.getenv("GOOGLE_DRIVE_HEADLESS_AUTH", "false").lower() == "true"
+    
+    if is_headless:
+        logger.info("Headless mode detected. Please follow the URL to authenticate.")
+        # run_local_server with open_browser=False is the modern replacement for run_console
+        creds = flow.run_local_server(port=0, open_browser=False)
+    else:
+        # Standard flow with browser
+        creds = flow.run_local_server(port=0)
+        
+    return creds

google_drive_forge/client.py

@@ -0,0 +1,140 @@
+import io
+import logging
+import functools
+from typing import List, Dict, Any, Optional, Union
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaIoBaseDownload, MediaFileUpload
+from googleapiclient.errors import HttpError
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+from .auth import get_credentials
+
+# Setup basic logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DriveClient:
+    def __init__(self):
+        self.creds = get_credentials()
+        self.service = build('drive', 'v3', credentials=self.creds)
+
+    @functools.lru_cache(maxsize=128)
+    def _cached_list_files(self, q: str, limit: int) -> List[Dict[str, Any]]:
+        """Internal cached method for listing files."""
+        results = self.service.files().list(
+            q=q,
+            pageSize=limit,
+            fields="nextPageToken, files(id, name, mimeType, parents, owners, modifiedTime, webViewLink, size)"
+        ).execute()
+        return results.get('files', [])
+
+    @retry(
+        retry=retry_if_exception_type(HttpError),
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10)
+    )
+    def list_files(self, query: str = None, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Lists files with retry logic.
+        """
+        try:
+            # Default query to not show trashed files if no query provided
+            if not query:
+                q = "trashed = false"
+            else:
+                q = f"({query}) and trashed = false"
+
+            return self._cached_list_files(q, limit)
+        except HttpError as error:
+            logger.error(f"An error occurred: {error}")
+            raise
+
+    @functools.lru_cache(maxsize=256)
+    def get_file_metadata(self, file_id: str) -> Dict[str, Any]:
+        """Get detailed metadata for a file."""
+        return self.service.files().get(
+            fileId=file_id,
+            fields="id, name, mimeType, parents, owners, modifiedTime, webViewLink, size, exportLinks"
+        ).execute()
+
+    def download_file(self, file_id: str, export_mime_type: Optional[str] = None) -> bytes:
+        """
+        Downloads a file's content.
+        Handles binary downloads and Google Workspace document exports.
+        """
+        try:
+            meta = self.get_file_metadata(file_id)
+            mime_type = meta.get('mimeType')
+
+            # Handle Google Workspace documents (Docs, Sheets, Slides)
+            if mime_type == 'application/vnd.google-apps.document':
+                # Default to text/plain if requested or for general text-based use
+                target_mime = export_mime_type or 'application/pdf'
+                request = self.service.files().export_media(fileId=file_id, mimeType=target_mime)
+            elif mime_type == 'application/vnd.google-apps.spreadsheet':
+                target_mime = export_mime_type or 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+                request = self.service.files().export_media(fileId=file_id, mimeType=target_mime)
+            elif mime_type == 'application/vnd.google-apps.presentation':
+                target_mime = export_mime_type or 'application/pdf'
+                request = self.service.files().export_media(fileId=file_id, mimeType=target_mime)
+            else:
+                # Standard binary download
+                request = self.service.files().get_media(fileId=file_id)
+
+            file_io = io.BytesIO()
+            downloader = MediaIoBaseDownload(file_io, request)
+            done = False
+            while done is False:
+                status, done = downloader.next_chunk()
+            
+            return file_io.getvalue()
+        except HttpError as error:
+            logger.error(f"Error downloading file {file_id}: {error}")
+            raise
+
+    def create_folder(self, name: str, parent_id: str = 'root') -> Dict[str, Any]:
+        """Create a new folder."""
+        file_metadata = {
+            'name': name,
+            'mimeType': 'application/vnd.google-apps.folder',
+            'parents': [parent_id]
+        }
+        return self.service.files().create(body=file_metadata, fields='id, name, webViewLink').execute()
+
+    def upload_file(self, name: str, content: Union[str, bytes], parent_id: str = 'root', mime_type: str = 'text/plain') -> Dict[str, Any]:
+        """Upload a file."""
+        file_metadata = {
+            'name': name,
+            'parents': [parent_id]
+        }
+        
+        if isinstance(content, str):
+            content_bytes = io.BytesIO(content.encode('utf-8'))
+        else:
+            content_bytes = io.BytesIO(content)
+
+        # Use MediaIoBaseUpload for in-memory bytes
+        from googleapiclient.http import MediaIoBaseUpload
+        media = MediaIoBaseUpload(content_bytes, mimetype=mime_type, resumable=True)
+
+        return self.service.files().create(
+            body=file_metadata,
+            media_body=media,
+            fields='id, name, webViewLink'
+        ).execute()
+
+    def trash_file(self, file_id: str) -> Dict[str, Any]:
+        """Move a file to trash."""
+        body = {'trashed': True}
+        return self.service.files().update(fileId=file_id, body=body).execute()
+
+    def list_folder_children(self, folder_id: str, limit: int = 100) -> List[Dict[str, Any]]:
+        """List all children of a specific folder."""
+        query = f"'{folder_id}' in parents"
+        return self.list_files(query=query, limit=limit)
+
+    def search(self, text: str, limit: int = 20) -> List[Dict[str, Any]]:
+        """Perform a semantic/name search."""
+        # Simple name contains search for now, can be expanded
+        query = f"name contains '{text}'"
+        return self.list_files(query=query, limit=limit)

google_drive_forge/executor.py

@@ -0,0 +1,73 @@
+import subprocess
+import os
+import sys
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ScriptExecutor:
+    def __init__(self, python_path: str, skills_dir: str):
+        self.skills_dir = skills_dir
+        
+        # Resolve the actual python executable
+        if os.path.isfile(python_path):
+            self.python_exe = python_path
+        else:
+            # Assume it's a venv directory
+            # Support both Unix (bin) and Windows (Scripts)
+            bin_path = os.path.join(python_path, "bin", "python")
+            if not os.path.exists(bin_path):
+                # Fallback for Windows or common alternative structures
+                bin_path = os.path.join(python_path, "Scripts", "python.exe")
+                if not os.path.exists(bin_path):
+                    # Second fallback: check if python is in the folder directly
+                    bin_path = os.path.join(python_path, "python")
+            
+            self.python_exe = bin_path if os.path.exists(bin_path) else python_path
+            
+        logger.info(f"ScriptExecutor initialized with Python: {self.python_exe}")
+
+    def run_skill(self, skill_name: str, args: list = None) -> str:
+        """
+        Runs a skill's main script.
+        Assumes the skill is in a folder: skills_dir/skill_name/script.py
+        """
+        script_path = os.path.join(self.skills_dir, skill_name, "script.py")
+        
+        if not os.path.exists(script_path):
+            return f"Error: Skill script not found at {script_path}"
+
+        cmd = [self.python_exe, script_path]
+        if args:
+            cmd.extend(args)
+
+        try:
+            # Add the current project directory to PYTHONPATH so scripts can import google_drive_forge
+            env = os.environ.copy()
+            # __file__ is inside google_drive_forge/, so go up one level to get the package root
+            package_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+            
+            # Ensure the skills can find the modules by importing 'google_drive_forge'
+            current_pythonpath = env.get("PYTHONPATH", "")
+            if current_pythonpath:
+                env["PYTHONPATH"] = f"{package_root}{os.pathsep}{current_pythonpath}"
+            else:
+                env["PYTHONPATH"] = package_root
+
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=False,
+                env=env,
+                cwd=mcp_root
+            )
+            
+            output = result.stdout
+            if result.stderr:
+                output += f"\n--- Errors/Warnings ---\n{result.stderr}"
+            
+            return output if output.strip() else "Script executed successfully with no output."
+
+        except Exception as e:
+            return f"Failed to execute skill: {str(e)}"

google_drive_forge/intelligent_client.py

@@ -0,0 +1,103 @@
+import logging
+import functools
+from typing import List, Dict, Any, Optional, Callable
+from googleapiclient.errors import HttpError
+from .client import DriveClient
+
+from .audit import AuditLogger
+
+logger = logging.getLogger(__name__)
+
+def self_healing_recovery(func: Callable):
+    """
+    Decorator that attempts autonomous recovery on Google Drive API failures.
+    Specifically targets 404 (Not Found) errors and logs events.
+    """
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        try:
+            return func(self, *args, **kwargs)
+        except HttpError as error:
+            if error.resp.status == 404:
+                file_id = kwargs.get('file_id') or (args[0] if args else None)
+                if file_id and isinstance(file_id, str):
+                    message = f"File ID '{file_id}' not found. Suggesting search recovery."
+                    if hasattr(self, 'audit'):
+                        self.audit.log_recovery(file_id, "Unknown (Need Search)", False)
+                    
+                    logger.info(f"Self-healing: {message}")
+                    raise HttpError(error.resp, f"Autonomous Recovery: {message} Use 'search_files' to find the new ID.".encode())
+            raise
+    return wrapper
+
+class IntelligentDriveClient(DriveClient):
+    """
+    An advanced Drive client that implements autonomous patterns and self-healing.
+    """
+    def __init__(self, audit: Optional[AuditLogger] = None):
+        super().__init__()
+        self.audit = audit
+    
+    @self_healing_recovery
+    def get_file_metadata(self, file_id: str) -> Dict[str, Any]:
+        return super().get_file_metadata(file_id)
+
+    @self_healing_recovery
+    def download_file(self, file_id: str, export_mime_type: Optional[str] = None) -> bytes:
+        """
+        Enhanced download with MIME-type intelligence.
+        Autonomously determines if a file needs export vs download.
+        """
+        try:
+            return super().download_file(file_id, export_mime_type=export_mime_type)
+        except HttpError as error:
+            # Add specific MIME-type failure handling if super().download_file fails
+            logger.error(f"Intelligent Download failed for {file_id}: {error}")
+            raise
+
+    def find_and_heal_path(self, path: str) -> Optional[str]:
+        """
+        Autonomous Path Discovery with Active Healing. 
+        If a path like /Project/2026/Budgt fails, it auto-corrects to the closest match.
+        """
+        parts = [p for p in path.split('/') if p]
+        current_parent = 'root'
+        healed_path_parts = []
+        
+        for part in parts:
+            # Try exact match first
+            results = self.list_files(query=f"name = '{part}' and '{current_parent}' in parents")
+            
+            if results:
+                current_parent = results[0]['id']
+                healed_path_parts.append(part)
+                continue
+                
+            # Exact match failed. Attempt Active Healing.
+            # 1. Get all children of the current parent
+            children = self.list_files(query=f"'{current_parent}' in parents")
+            
+            # 2. Simple fuzzy match: case-insensitive match or name contains
+            matches = [c for c in children if part.lower() in c['name'].lower()]
+            
+            if len(matches) == 1:
+                # High confidence recovery
+                healed_name = matches[0]['name']
+                old_id = current_parent
+                current_parent = matches[0]['id']
+                
+                logger.info(f"Active Healing: Resolved '{part}' -> '{healed_name}' in folder {old_id}")
+                if self.audit:
+                    self.audit.log_recovery(part, healed_name, True)
+                
+                healed_path_parts.append(healed_name)
+            else:
+                # No definitive match
+                if self.audit:
+                    self.audit.log_recovery(part, "Ambiguous/Not Found", False)
+                
+                suggestion_names = [c["name"] for c in children]
+                logger.warning(f"Path break at '{part}'. Suggestions: {suggestion_names}")
+                return None
+            
+        return current_parent

google_drive_forge/resources.py

@@ -0,0 +1,29 @@
+from mcp.server.fastmcp import Context, FastMCP
+from .client import DriveClient
+
+def register_resources(mcp: FastMCP, client: DriveClient):
+    """Registers resource handlers to the MCP server."""
+
+    @mcp.resource("gdrive://{file_id}/content")
+    def get_file_content(file_id: str) -> str:
+        """
+        Reads the content of a file from Google Drive.
+        Automatic export for Google Docs/Sheets/Slides (to PDF/Excel).
+        """
+        try:
+            content_bytes = client.download_file(file_id)
+            
+            # Try to decode as text first
+            try:
+                return content_bytes.decode('utf-8')
+            except UnicodeDecodeError:
+                # If binary, return a representation or base64? 
+                # MCP text resources expect string. For binary, we might need a different approach 
+                # or just indicate it's binary.
+                # For now, let's return a clear message or a hex representation if small?
+                # A better pattern for binary files in MCP is usually not raw text resource 
+                # unless using the 'blob' resource type (which FastMCP might wrap differently).
+                # FastMCP resource decorators typically return text.
+                return f"<Binary Content: {len(content_bytes)} bytes>"
+        except Exception as e:
+            return f"Error reading file {file_id}: {str(e)}"

google_drive_forge/skill_loader.py

@@ -0,0 +1,65 @@
+import os
+import yaml
+import logging
+from typing import List, Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+class SkillMetadata:
+    def __init__(self, name: str, description: str, folder_path: str):
+        self.name = name
+        self.description = description
+        self.folder_path = folder_path
+
+class SkillLoader:
+    def __init__(self, skills_dir: str):
+        self.skills_dir = skills_dir
+
+    def discover_skills(self) -> List[SkillMetadata]:
+        """
+        Scans the skills directory for valid skill folders (containing SKILL.md).
+        """
+        skills = []
+        if not os.path.exists(self.skills_dir):
+            logger.warning(f"Skills directory not found: {self.skills_dir}")
+            return skills
+
+        for entry in os.scandir(self.skills_dir):
+            if entry.is_dir():
+                skill_md_path = os.path.join(entry.path, "SKILL.md")
+                if os.path.exists(skill_md_path):
+                    try:
+                        meta = self._parse_skill_md(skill_md_path, entry.path)
+                        if meta:
+                            skills.append(meta)
+                    except Exception as e:
+                        logger.error(f"Error parsing {skill_md_path}: {e}")
+        
+        return skills
+
+    def _parse_skill_md(self, file_path: str, folder_path: str) -> Optional[SkillMetadata]:
+        """
+        Parses the YAML frontmatter from a SKILL.md file.
+        """
+        with open(file_path, "r") as f:
+            content = f.read()
+        
+        if not content.startswith("---"):
+            return None
+
+        # Basic YAML frontmatter extraction
+        parts = content.split("---", 2)
+        if len(parts) < 3:
+            return None
+        
+        try:
+            frontmatter = yaml.safe_load(parts[1])
+            name = frontmatter.get("name")
+            description = frontmatter.get("description")
+            
+            if name and description:
+                return SkillMetadata(name, description, folder_path)
+        except Exception:
+            return None
+            
+        return None

google_drive_forge/tools.py

@@ -0,0 +1,324 @@
+from typing import Optional, List
+from mcp.server.fastmcp import Context, FastMCP
+from .client import DriveClient
+from .executor import ScriptExecutor
+from .skill_loader import SkillLoader
+from .audit import AuditLogger
+
+def register_tools(mcp: FastMCP, client: DriveClient):
+    """Registers tool handlers to the MCP server."""
+
+    @mcp.tool()
+    def list_files(limit: int = 20) -> str:
+        """
+        List the most recent files in Google Drive.
+        
+        Args:
+            limit: Number of files to return (default 20, max 100).
+        """
+        import json
+        files = client.list_files(limit=limit)
+        return json.dumps(files, indent=2)
+
+    @mcp.tool()
+    def search_files(query: str, limit: int = 20) -> str:
+        """
+        Search for files in Google Drive by name.
+        
+        Args:
+            query: The search text (e.g. project name).
+            limit: Max results.
+        """
+        import json
+        files = client.search(query, limit=limit)
+        return json.dumps(files, indent=2)
+
+    @mcp.tool()
+    def list_folder(folder_id: str, limit: int = 50) -> str:
+        """
+        List all children (files and subfolders) of a specific folder.
+        
+        Args:
+            folder_id: The ID of the folder to list. Use 'root' for top level.
+            limit: Limit results.
+        """
+        import json
+        files = client.list_folder_children(folder_id, limit=limit)
+        return json.dumps(files, indent=2)
+
+    @mcp.tool()
+    def get_file_metadata(file_id: str) -> str:
+        """
+        Get detailed metadata for a file.
+        
+        Args:
+            file_id: The ID of the file.
+        """
+        import json
+        meta = client.get_file_metadata(file_id)
+        return json.dumps(meta, indent=2)
+
+    @mcp.tool()
+    def create_folder(name: str, parent_id: str = 'root') -> str:
+        """
+        Create a new folder.
+        
+        Args:
+            name: Name of the new folder.
+            parent_id: ID of the parent folder (default 'root').
+        """
+        import json
+        res = client.create_folder(name, parent_id)
+        return json.dumps(res, indent=2)
+
+    @mcp.tool()
+    def upload_file(name: str, content: str, parent_id: str = 'root') -> str:
+        """
+        Upload a text file to Google Drive.
+        
+        Args:
+            name: Name of the file.
+            content: Text content of the file.
+            parent_id: ID of the parent folder.
+        """
+        import json
+        res = client.upload_file(name, content, parent_id=parent_id)
+        return json.dumps(res, indent=2)
+
+    @mcp.tool()
+    def trash_file(file_id: str) -> str:
+        """
+        Move a file to the trash.
+        
+        Args:
+            file_id: ID of the file to trash.
+        """
+        import json
+        res = client.trash_file(file_id)
+        return json.dumps(res, indent=2)
+
+def register_intelligent_tools(mcp: FastMCP, client: DriveClient, executor: ScriptExecutor, loader: SkillLoader, audit: AuditLogger):
+    """Registers the 'Forge' and 'Autonomy' tools to the MCP server."""
+
+    @mcp.tool()
+    def create_skill(name: str, code: str, description: str) -> str:
+        """
+        Forges a new capability (Skill) by writing a Python script.
+        
+        Args:
+            name: Technical name of the skill (e.g., 'archive_old_files'). No spaces.
+            code: The Python code for the script.
+            description: What this skill does (will be saved in SKILL.md).
+        """
+        import os
+        import re
+        
+        # Sanitize name
+        safe_name = re.sub(r'[^a-zA-Z0-9_]', '_', name).lower()
+        
+        skill_dir = os.path.join(loader.skills_dir, safe_name)
+        os.makedirs(skill_dir, exist_ok=True)
+        
+        # Write script.py
+        with open(os.path.join(skill_dir, "script.py"), "w") as f:
+            f.write(code)
+            
+        # Write SKILL.md
+        skill_md_content = f"""---
+name: {safe_name}
+description: {description}
+---
+
+{description}
+"""
+        with open(os.path.join(skill_dir, "SKILL.md"), "w") as f:
+            f.write(skill_md_content)
+            
+        # Log to Audit
+        audit.log_skill_creation(safe_name)
+            
+        return f"Skill '{safe_name}' forged successfully in {skill_dir}"
+
+    @mcp.tool()
+    def list_skills() -> str:
+        """
+        Lists all available AI-forged skills in the library.
+        """
+        import json
+        skills = loader.discover_skills()
+        return json.dumps([{"name": s.name, "description": s.description} for s in skills], indent=2)
+
+    @mcp.tool()
+    def update_skill(name: str, code: str, description: Optional[str] = None) -> str:
+        """
+        Updates an existing skill with new code or description.
+        
+        Args:
+            name: Technical name of the skill to update.
+            code: The new Python code.
+            description: Optional updated description.
+        """
+        import os
+        import re
+        
+        safe_name = re.sub(r'[^a-zA-Z0-9_]', '_', name).lower()
+        skill_dir = os.path.join(loader.skills_dir, safe_name)
+        
+        if not os.path.exists(skill_dir):
+            return f"Error: Skill '{safe_name}' does not exist. Use create_skill first."
+        
+        # Update script.py
+        with open(os.path.join(skill_dir, "script.py"), "w") as f:
+            f.write(code)
+            
+        # Update SKILL.md if description provided
+        if description:
+            skill_md_content = f"""---
+name: {safe_name}
+description: {description}
+---
+
+{description}
+"""
+            with open(os.path.join(skill_dir, "SKILL.md"), "w") as f:
+                f.write(skill_md_content)
+        
+        audit.log_event("SKILL_UPDATE", f"Capability updated: {safe_name}")
+        return f"Skill '{safe_name}' updated successfully."
+
+    @mcp.tool()
+    def run_skill(name: str, args: Optional[List[str]] = None) -> str:
+        """
+        Executes an AI-forged skill from the library.
+        
+        Args:
+            name: The name of the skill to run.
+            args: Optional list of command-line arguments for the script.
+        """
+        import re
+        safe_name = re.sub(r'[^a-zA-Z0-9_]', '_', name).lower()
+        return executor.run_skill(safe_name, args)
+
+    @mcp.tool()
+    def resolve_path(path: str) -> str:
+        """
+        Intelligently resolves a human-readable path (e.g., '/Projects/2026') to a File ID.
+        Includes autonomous healing if the path is broken.
+        
+        Args:
+            path: The full path to resolve.
+        """
+        file_id = client.find_and_heal_path(path)
+        if file_id:
+            return f"Resolved '{path}' to ID: {file_id}"
+        return f"Error: Could not resolve path '{path}'. Check logs for suggestions."
+
+
+    @mcp.tool()
+    def get_skill_guide() -> str:
+        """
+        Returns the detailed manual (SKILL.md) for Google Drive Forge.
+        Read this to understand how to use autonomous features, The Forge, and script templates.
+        """
+        import os
+        
+        # Locate SKILL.md in the root of the MCP installation
+        # Helper: tools.py is in src/, so root is ../
+        base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        skill_md_path = os.path.join(base_dir, "SKILL.md")
+        
+        if not os.path.exists(skill_md_path):
+            return "Error: SKILL.md not found in the MCP root directory."
+            
+        with open(skill_md_path, "r", encoding="utf-8") as f:
+            return f.read()
+
+    @mcp.tool()
+    def download_to_local(file_id: str, local_path: str) -> str:
+        """
+        Downloads a file from Drive to the local filesystem.
+        Automatically converts Google Docs/Sheets to meaningful text/markdown formats.
+        
+        Args:
+            file_id: The ID of the file to download.
+            local_path: Absolute path on the local machine to save the file.
+        """
+        import os
+        try:
+            # 1. Get Metadata to check type
+            meta = client.get_file_metadata(file_id)
+            name = meta.get('name')
+            mime_type = meta.get('mimeType')
+            
+            # 2. Determine conversion (if needed)
+            content = None
+            final_path = local_path
+            
+            # Normalize path: if directory, append filename
+            if os.path.isdir(local_path) or local_path.endswith(os.sep):
+                os.makedirs(local_path, exist_ok=True)
+                final_path = os.path.join(local_path, name)
+            
+            # Ensure parent dir exists
+            os.makedirs(os.path.dirname(final_path), exist_ok=True)
+
+            if mime_type == 'application/vnd.google-apps.document':
+                # Export as text for Docs
+                content = client.download_file(file_id, export_mime_type='text/plain')
+                if not final_path.endswith(('.txt', '.md')):
+                    final_path += '.md'
+            elif mime_type == 'application/vnd.google-apps.spreadsheet':
+                # Export as CSV for Sheets (easy to read) or Excel
+                 content = client.download_file(file_id, export_mime_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+                 if not final_path.endswith('.xlsx'):
+                    final_path += '.xlsx'
+            else:
+                # Binary / Default
+                content = client.download_file(file_id)
+            
+            # 3. Write to Disk
+            with open(final_path, 'wb') as f:
+                if isinstance(content, str):
+                    f.write(content.encode('utf-8'))
+                else:
+                    f.write(content)
+                    
+            return f"Successfully downloaded '{name}' to '{final_path}'"
+            
+        except Exception as e:
+            return f"Error downloading file: {str(e)}"
+
+    @mcp.tool()
+    def smart_read(path: str) -> str:
+        """
+        Resolves a path and reads its content in one step.
+        Autonomously handles path healing and MIME-type conversion.
+        
+        Args:
+            path: Path to the file.
+        """
+        file_id = client.find_and_heal_path(path)
+        if not file_id:
+            return f"Error: Could not resolve path '{path}'"
+        
+        try:
+            # Check if it's a Google Doc that needs text export
+            meta = client.get_file_metadata(file_id)
+            mime_type = meta.get('mimeType')
+            
+            if mime_type == 'application/vnd.google-apps.document':
+                # Force text export for reading
+                content_bytes = client.download_file(file_id, export_mime_type='text/plain')
+            else:
+                content_bytes = client.download_file(file_id)
+
+            # Try to decode
+            if isinstance(content_bytes, str):
+                return content_bytes
+            
+            try:
+                return content_bytes.decode('utf-8')
+            except UnicodeDecodeError:
+                return f"<Binary Content: {len(content_bytes)} bytes> (MIME: {mime_type})"
+        except Exception as e:
+            return f"Error reading file at '{path}': {str(e)}"

google_drive_forge-0.2.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: google-drive-forge
+Version: 0.2.0
+Summary: Autonomous Google Drive MCP with Skill Forge Capabilities
+Project-URL: Homepage, https://github.com/traylinx/google_drive_forge
+Project-URL: Repository, https://github.com/traylinx/google_drive_forge
+Project-URL: Documentation, https://github.com/traylinx/google_drive_forge#readme
+Author-email: Sebastian Velandia <sebastian@traylinx.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agentic,ai,automation,google-drive,mcp,skill-forge
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: google-api-python-client
+Requires-Dist: google-auth
+Requires-Dist: google-auth-httplib2
+Requires-Dist: google-auth-oauthlib
+Requires-Dist: mcp
+Requires-Dist: pyyaml
+Requires-Dist: tenacity
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img src="assets/banner.png" width="250" alt="Google Drive Forge Icon">
+  <h1>Google Drive Forge</h1>
+</div>
+
+[![MCP](https://img.shields.io/badge/MCP-Protocol-blue.svg)](https://modelcontextprotocol.io)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+Transform your AI agent from a simple file explorer into an **Autonomous Power-User**. This isn't just a Google Drive connector; it's a cognitive layer for your cloud storage.
+
+---
+
+## 💎 The "Intelligent" Edge
+
+Most MCP servers just list files. This one **reasons** about them.
+
+| Feature             | Description                                               | Benefit                                                         |
+| :------------------ | :-------------------------------------------------------- | :-------------------------------------------------------------- |
+| **🔨 The Forge**     | On-the-fly Python "Skill" creation and execution.         | Solve complex tasks like "Archive all PDFs older than 30 days". |
+| **🩹 Path Healing**  | Fuzzy, human-like path resolution (e.g., `/Work/Drafts`). | No more hunting for obscure File IDs.                           |
+| **🧠 Auto-Recovery** | Intercepts 404s and suggests correct paths/files.         | Agent remains autonomous even when it makes mistakes.           |
+| **🔍 Smart Read**    | Auto-detection of MIME types and content conversion.      | Seamless interaction with Sheets, Docs, and PDFs.               |
+| **📜 Audit Log**     | Transparent tracking of all autonomous decisions.         | Complete visibility into what your agent is doing.              |
+
+---
+
+## 🛠 Features Breakdown
+
+### 📂 Standard Operations
+- **Discovery**: `list_files`, `search_files`, `list_folder`.
+- **Management**: `create_folder`, `upload_file`, `trash_file`.
+- **Metadata**: Deep metadata inspection for any file object.
+
+### ⚡ The Forge (Agent Skills)
+Empower your agent to expand its own capabilities. Using the [Agent Skills](https://agentskills.io) standard, the agent can:
+- **`create_skill`**: Write Python logic to perform multi-step Drive operations.
+- **`list_skills`**: Browse its library of forged capabilities.
+- **`run_skill`**: Execute its custom logic with full API access.
+
+### 🧭 Autonomous Navigation
+- **`resolve_path`**: Converts `/Project/2026/Budget.xlsx` into a working ID, healing broken paths automatically.
+- **`smart_read`**: A high-level tool that handles resolution, downloading, and decoding in one step.
+
+---
+
+## � Getting Started
+
+### 1. Requirements
+- Python 3.10 or higher.
+- A Google Cloud Project with the **Drive API** enabled.
+
+### 2. Deep Dive Into Setup
+For a step-by-step walkthrough on generating your `credentials.json` and `token.json`, please refer to our:
+👉 **[Comprehensive Setup Guide](docs/setup.md)**
+
+### 3. Quick Configuration
+Add this to your MCP host configuration (e.g., Antigravity):
+
+```json
+"google-drive": {
+  "command": "python",
+  "args": ["/path/to/server.py"],
+  "env": {
+    "GOOGLE_DRIVE_CREDENTIALS": "/path/to/credentials.json",
+    "GOOGLE_DRIVE_HEADLESS_AUTH": "false",
+    "GOOGLE_DRIVE_PYTHON_PATH": "/usr/bin/python3"
+  }
+}
+```
+
+#### ⚙️ Environment Variables
+| Variable                     | Description                                       | Default              |
+| :--------------------------- | :------------------------------------------------ | :------------------- |
+| `GOOGLE_DRIVE_CREDENTIALS`   | Path to your `credentials.json`.                  | `./credentials.json` |
+| `GOOGLE_DRIVE_HEADLESS_AUTH` | Set to `true` for console-based OAuth on servers. | `false`              |
+| `GOOGLE_DRIVE_PYTHON_PATH`   | Path to a specific Python executable or venv.     | `sys.executable`     |
+| `GOOGLE_DRIVE_SKILLS_DIR`    | Where to store forged AI Skills.                  | `./skills`           |
+
+---
+
+## 🛡️ Security Implications
+
+**Please Read Carefully:**
+This MCP server implements **The Forge**, which allows AI agents to write and execute arbitrary Python code on your machine. 
+*   **Local Use Only**: This tool is designed for local power-users. 
+*   **Sandbox**: It does not currently implement a sandbox for executed scripts. Only use it with agents you trust to handle your local filesystem.
+
+---
+
+##  Contributing & Extension
+
+We believe in open autonomy. If you have ideas for new core skills or improvements to the path-healing engine:
+1. Check the [Contributing Guide](CONTRIBUTING.md).
+2. Explore the `skills/` directory for examples of forged logic.
+3. Submit a PR!
+
+---
+
+## ⚖️ License
+
+Distributed under the **MIT License**. See `LICENSE` for more information.
+
+---
+<p align="center">
+  Built with ❤️ for the next generation of AI Agents.
+</p>

google_drive_forge-0.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+google_drive_forge/__init__.py,sha256=z_vaI-6hkbxOK0JGD31H2n2i_yIkQ3cAFA3xF3I-xLI,321
+google_drive_forge/__main__.py,sha256=F8Ucw5KoaMRuG6Elo7LIMr1xJsSh0h0FmgeX637jSLk,1859
+google_drive_forge/audit.py,sha256=k5tpSwUEzgITMz0oPmT2rP76a0VHLexkSRx3ZZ0nWgw,1304
+google_drive_forge/auth.py,sha256=oIVQVn148z33loEt5Irts2fMUOqqvczy_aJMReNNkrs,2771
+google_drive_forge/client.py,sha256=Mnf45E3WB6z8tLEx3jGTyzmFlJr11L-z-AFqbfelHiI,5809
+google_drive_forge/executor.py,sha256=kwUrRKVqqrqGHzWpHaCSWCP5bDnigo9qtAwrfA7Md2Y,2861
+google_drive_forge/intelligent_client.py,sha256=I5k7mlmRHByhAlNksdkeTSGpXRA98IMaCxMmFw8EEmg,4228
+google_drive_forge/resources.py,sha256=6UEeFY8D0mPaQ8aBeLIB1H7lo7689i9uX9_YhkHWG6Y,1402
+google_drive_forge/skill_loader.py,sha256=LMboX7L-TIamVv0Ynhtjc4TnxTEyWhY-Xsf646cUnK4,2114
+google_drive_forge/tools.py,sha256=UWW1rPN4itpj5CHWYZScGXPDqekd2vNpr4_o-ElKJEc,11230
+google_drive_forge-0.2.0.dist-info/METADATA,sha256=Zp8jrtFp6wwhbCkx98mpFU_zvq6_Wx9iSwC-b94vbbU,6087
+google_drive_forge-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+google_drive_forge-0.2.0.dist-info/entry_points.txt,sha256=5WcFKx8JkaDAXsvd0EUThiUmSgYDvwoI_pNVoMqPNoI,72
+google_drive_forge-0.2.0.dist-info/licenses/LICENSE,sha256=uq6rz2JUfUAfzLRl8jdFrOsB-cyVv0LNRtbsn0ikPac,1088
+google_drive_forge-0.2.0.dist-info/RECORD,,

google_drive_forge-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

google_drive_forge-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+google-drive-forge = google_drive_forge.__main__:main

google_drive_forge-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Google Drive Forge Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.