anchi-kit 1.2.0 → 1.2.2

package/.antigravity/skills/ai-multimodal/scripts/check_setup.py

@@ -1,299 +0,0 @@
-#!/usr/bin/env python3
-"""
-Validate ai-multimodal skill setup and configuration.
-
-Checks:
-- API key presence and format
-- Python dependencies
-- Centralized resolver availability
-- Directory structure
-"""
-
-import os
-import sys
-from pathlib import Path
-
-# Color codes for terminal output
-GREEN = '\033[92m'
-YELLOW = '\033[93m'
-RED = '\033[91m'
-BLUE = '\033[94m'
-RESET = '\033[0m'
-BOLD = '\033[1m'
-
-
-def print_header(text):
-    """Print section header."""
-    print(f"\n{BOLD}{BLUE}{'='*60}{RESET}")
-    print(f"{BOLD}{BLUE}{text}{RESET}")
-    print(f"{BOLD}{BLUE}{'='*60}{RESET}\n")
-
-
-def print_success(text):
-    """Print success message."""
-    print(f"{GREEN}✓ {text}{RESET}")
-
-
-def print_warning(text):
-    """Print warning message."""
-    print(f"{YELLOW}⚠ {text}{RESET}")
-
-
-def print_error(text):
-    """Print error message."""
-    print(f"{RED}✗ {text}{RESET}")
-
-
-def print_info(text):
-    """Print info message."""
-    print(f"{BLUE}ℹ {text}{RESET}")
-
-
-def check_dependencies():
-    """Check if required Python packages are installed."""
-    print_header("Checking Python Dependencies")
-
-    dependencies = {
-        'google.genai': 'google-genai',
-        'dotenv': 'python-dotenv',
-        'PIL': 'pillow'
-    }
-
-    missing = []
-
-    for module_name, package_name in dependencies.items():
-        try:
-            __import__(module_name)
-            print_success(f"{package_name} is installed")
-        except ImportError:
-            print_error(f"{package_name} is NOT installed")
-            missing.append(package_name)
-
-    if missing:
-        print_error("\nMissing dependencies detected!")
-        print_info(f"Install with: pip install {' '.join(missing)}")
-        return False
-
-    return True
-
-
-def check_centralized_resolver():
-    """Check if centralized resolver is available."""
-    print_header("Checking Centralized Resolver")
-
-    resolver_path = Path.home() / '.cursor' / 'scripts' / 'resolve_env.py'
-
-    if resolver_path.exists():
-        print_success(f"Centralized resolver found: {resolver_path}")
-
-        # Try to import it
-        sys.path.insert(0, str(resolver_path.parent))
-        try:
-            from resolve_env import resolve_env
-            print_success("Centralized resolver can be imported")
-            return True
-        except ImportError as e:
-            print_error(f"Centralized resolver exists but cannot be imported: {e}")
-            return False
-    else:
-        print_warning(f"Centralized resolver not found: {resolver_path}")
-        print_info("Skill will use fallback resolution logic")
-        return True  # Not critical, fallback works
-
-
-def find_api_key():
-    """Find and validate API key using centralized resolver."""
-    print_header("Checking API Key Configuration")
-
-    # Try to use centralized resolver
-    sys.path.insert(0, str(Path.home() / '.cursor' / 'scripts'))
-    try:
-        from resolve_env import resolve_env
-
-        print_info("Using centralized resolver...")
-        api_key = resolve_env('GEMINI_API_KEY', skill='ai-multimodal')
-
-        if api_key:
-            print_success("API key found via centralized resolver")
-            print_info(f"Key preview: {api_key[:20]}...{api_key[-4:]}")
-
-            # Show hierarchy
-            print_info("\nTo see where the key was found, run:")
-            print_info("python ~/.cursor/scripts/resolve_env.py GEMINI_API_KEY --skill ai-multimodal --verbose")
-
-            return api_key
-        else:
-            print_error("API key not found in any location")
-            return None
-
-    except ImportError:
-        print_warning("Centralized resolver not available, using fallback")
-
-        # Fallback: check environment
-        api_key = os.getenv('GEMINI_API_KEY')
-        if api_key:
-            print_success("API key found in process.env")
-            print_info(f"Key preview: {api_key[:20]}...{api_key[-4:]}")
-            return api_key
-        else:
-            print_error("API key not found")
-            return None
-
-
-def validate_api_key_format(api_key):
-    """Basic validation of API key format."""
-    if not api_key:
-        return False
-
-    # Google AI Studio keys typically start with 'AIza'
-    if api_key.startswith('AIza'):
-        print_success("API key format looks valid (Google AI Studio)")
-        return True
-    elif len(api_key) > 20:
-        print_warning("API key format not recognized (may be Vertex AI or custom)")
-        return True
-    else:
-        print_error("API key format looks invalid (too short)")
-        return False
-
-
-def test_api_connection(api_key):
-    """Test API connection with a simple request."""
-    print_header("Testing API Connection")
-
-    try:
-        from google import genai
-
-        print_info("Initializing Gemini client...")
-        client = genai.Client(api_key=api_key)
-
-        print_info("Fetching available models...")
-        # List models to verify API key works
-        models = list(client.models.list())
-
-        print_success(f"API connection successful! Found {len(models)} available models")
-
-        # Show some available models
-        print_info("\nSample available models:")
-        for model in models[:5]:
-            print(f"  - {model.name}")
-
-        return True
-
-    except ImportError:
-        print_error("google-genai package not installed")
-        return False
-    except Exception as e:
-        print_error(f"API connection failed: {str(e)}")
-        return False
-
-
-def check_directory_structure():
-    """Verify skill directory structure."""
-    print_header("Checking Directory Structure")
-
-    script_dir = Path(__file__).parent
-    skill_dir = script_dir.parent
-
-    required_files = [
-        ('SKILL.md', skill_dir / 'SKILL.md'),
-        ('.env.example', skill_dir / '.env.example'),
-        ('gemini_batch_process.py', script_dir / 'gemini_batch_process.py'),
-    ]
-
-    all_exist = True
-
-    for name, path in required_files:
-        if path.exists():
-            print_success(f"{name} exists")
-        else:
-            print_error(f"{name} NOT found at {path}")
-            all_exist = False
-
-    return all_exist
-
-
-def provide_setup_instructions():
-    """Provide setup instructions if configuration is incomplete."""
-    print_header("Setup Instructions")
-
-    print_info("To configure the ai-multimodal skill:")
-    print("\n1. Get a Gemini API key:")
-    print("   → Visit: https://aistudio.google.com/apikey")
-
-    print("\n2. Configure the API key (choose one method):")
-
-    print(f"\n   Option A: User global config (recommended)")
-    print(f"   $ echo 'GEMINI_API_KEY=your-api-key-here' >> ~/.cursor/.env")
-
-    script_dir = Path(__file__).parent
-    skill_dir = script_dir.parent
-
-    print(f"\n   Option B: Skill-specific config")
-    print(f"   $ cd {skill_dir}")
-    print(f"   $ cp .env.example .env")
-    print(f"   $ # Edit .env and add your API key")
-
-    print(f"\n   Option C: Runtime environment (temporary)")
-    print(f"   $ export GEMINI_API_KEY='your-api-key-here'")
-
-    print("\n3. Verify setup:")
-    print(f"   $ python {Path(__file__)}")
-
-    print("\n4. Debug if needed:")
-    print(f"   $ python ~/.cursor/scripts/resolve_env.py --show-hierarchy --skill ai-multimodal")
-    print(f"   $ python ~/.cursor/scripts/resolve_env.py GEMINI_API_KEY --skill ai-multimodal --verbose")
-
-
-def main():
-    """Run all setup checks."""
-    print(f"\n{BOLD}AI Multimodal Skill - Setup Checker{RESET}")
-
-    all_passed = True
-
-    # Check directory structure
-    if not check_directory_structure():
-        all_passed = False
-
-    # Check centralized resolver
-    check_centralized_resolver()
-
-    # Check dependencies
-    if not check_dependencies():
-        all_passed = False
-        provide_setup_instructions()
-        sys.exit(1)
-
-    # Check API key
-    api_key = find_api_key()
-
-    if not api_key:
-        print_error("\n❌ GEMINI_API_KEY not found in any location")
-        all_passed = False
-        provide_setup_instructions()
-        sys.exit(1)
-
-    # Validate API key format
-    if not validate_api_key_format(api_key):
-        all_passed = False
-
-    # Test API connection
-    if not test_api_connection(api_key):
-        all_passed = False
-
-    # Final summary
-    print_header("Setup Summary")
-
-    if all_passed:
-        print_success("✅ All checks passed! The ai-multimodal skill is ready to use.")
-        print_info("\nNext steps:")
-        print("  • Read SKILL.md for usage examples")
-        print("  • Try: python scripts/gemini_batch_process.py --help")
-        print("  • Generate image: python scripts/gemini_batch_process.py --task generate --prompt 'A sunset' --model gemini-2.5-flash-image")
-    else:
-        print_error("❌ Some checks failed. Please fix the issues above.")
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    main()

package/.antigravity/skills/ai-multimodal/scripts/document_converter.py

@@ -1,395 +0,0 @@
-#!/usr/bin/env python3
-"""
-Convert documents to Markdown using Gemini API.
-
-Supports all document types:
-- PDF documents (native vision processing)
-- Images (JPEG, PNG, WEBP, HEIC)
-- Office documents (DOCX, XLSX, PPTX)
-- HTML, TXT, and other text formats
-
-Features:
-- Converts to clean markdown format
-- Preserves structure, tables, and formatting
-- Extracts text from images and scanned documents
-- Batch conversion support
-- Saves to docs/assets/document-extraction.md by default
-"""
-
-import argparse
-import os
-import sys
-import time
-from pathlib import Path
-from typing import Optional, List, Dict, Any
-
-try:
-    from google import genai
-    from google.genai import types
-except ImportError:
-    print("Error: google-genai package not installed")
-    print("Install with: pip install google-genai")
-    sys.exit(1)
-
-try:
-    from dotenv import load_dotenv
-except ImportError:
-    load_dotenv = None
-
-
-def find_api_key() -> Optional[str]:
-    """Find Gemini API key using correct priority order.
-
-    Priority order (highest to lowest):
-    1. process.env (runtime environment variables)
-    2. .cursor/skills/ai-multimodal/.env (skill-specific config)
-    3. .cursor/skills/.env (shared skills config)
-    4. .cursor/.env (Claude global config)
-    """
-    # Priority 1: Already in process.env (highest)
-    api_key = os.getenv('GEMINI_API_KEY')
-    if api_key:
-        return api_key
-
-    # Load .env files if dotenv available
-    if load_dotenv:
-        # Determine base paths
-        script_dir = Path(__file__).parent
-        skill_dir = script_dir.parent  # .cursor/skills/ai-multimodal
-        skills_dir = skill_dir.parent   # .cursor/skills
-        claude_dir = skills_dir.parent  # .cursor
-
-        # Priority 2: Skill-specific .env
-        env_file = skill_dir / '.env'
-        if env_file.exists():
-            load_dotenv(env_file)
-            api_key = os.getenv('GEMINI_API_KEY')
-            if api_key:
-                return api_key
-
-        # Priority 3: Shared skills .env
-        env_file = skills_dir / '.env'
-        if env_file.exists():
-            load_dotenv(env_file)
-            api_key = os.getenv('GEMINI_API_KEY')
-            if api_key:
-                return api_key
-
-        # Priority 4: Claude global .env
-        env_file = claude_dir / '.env'
-        if env_file.exists():
-            load_dotenv(env_file)
-            api_key = os.getenv('GEMINI_API_KEY')
-            if api_key:
-                return api_key
-
-    return None
-
-
-def find_project_root() -> Path:
-    """Find project root directory."""
-    script_dir = Path(__file__).parent
-
-    # Look for .git or .cursor directory
-    for parent in [script_dir] + list(script_dir.parents):
-        if (parent / '.git').exists() or (parent / '.cursor').exists():
-            return parent
-
-    return script_dir
-
-
-def get_mime_type(file_path: str) -> str:
-    """Determine MIME type from file extension."""
-    ext = Path(file_path).suffix.lower()
-
-    mime_types = {
-        # Documents
-        '.pdf': 'application/pdf',
-        '.txt': 'text/plain',
-        '.html': 'text/html',
-        '.htm': 'text/html',
-        '.md': 'text/markdown',
-        '.csv': 'text/csv',
-        # Images
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg',
-        '.png': 'image/png',
-        '.webp': 'image/webp',
-        '.heic': 'image/heic',
-        '.heif': 'image/heif',
-        # Office (need to be uploaded as binary)
-        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-    }
-
-    return mime_types.get(ext, 'application/octet-stream')
-
-
-def upload_file(client: genai.Client, file_path: str, verbose: bool = False) -> Any:
-    """Upload file to Gemini File API."""
-    if verbose:
-        print(f"Uploading {file_path}...")
-
-    myfile = client.files.upload(file=file_path)
-
-    # Wait for processing if needed
-    max_wait = 300  # 5 minutes
-    elapsed = 0
-    while myfile.state.name == 'PROCESSING' and elapsed < max_wait:
-        time.sleep(2)
-        myfile = client.files.get(name=myfile.name)
-        elapsed += 2
-        if verbose and elapsed % 10 == 0:
-            print(f"  Processing... {elapsed}s")
-
-    if myfile.state.name == 'FAILED':
-        raise ValueError(f"File processing failed: {file_path}")
-
-    if myfile.state.name == 'PROCESSING':
-        raise TimeoutError(f"Processing timeout after {max_wait}s: {file_path}")
-
-    if verbose:
-        print(f"  Uploaded: {myfile.name}")
-
-    return myfile
-
-
-def convert_to_markdown(
-    client: genai.Client,
-    file_path: str,
-    model: str = 'gemini-2.5-flash',
-    custom_prompt: Optional[str] = None,
-    verbose: bool = False,
-    max_retries: int = 3
-) -> Dict[str, Any]:
-    """Convert a document to markdown using Gemini."""
-
-    for attempt in range(max_retries):
-        try:
-            file_path_obj = Path(file_path)
-            file_size = file_path_obj.stat().st_size
-            use_file_api = file_size > 20 * 1024 * 1024  # >20MB
-
-            # Default prompt for markdown conversion
-            if custom_prompt:
-                prompt = custom_prompt
-            else:
-                prompt = """Convert this document to clean, well-formatted Markdown.
-
-Requirements:
-- Preserve all content, structure, and formatting
-- Convert tables to markdown table format
-- Maintain heading hierarchy (# ## ### etc)
-- Preserve lists, code blocks, and quotes
-- Extract text from images if present
-- Keep formatting consistent and readable
-
-Output only the markdown content without any preamble or explanation."""
-
-            # Upload or inline the file
-            if use_file_api:
-                myfile = upload_file(client, str(file_path), verbose)
-                content = [prompt, myfile]
-            else:
-                with open(file_path, 'rb') as f:
-                    file_bytes = f.read()
-
-                mime_type = get_mime_type(str(file_path))
-                content = [
-                    prompt,
-                    types.Part.from_bytes(data=file_bytes, mime_type=mime_type)
-                ]
-
-            # Generate markdown
-            response = client.models.generate_content(
-                model=model,
-                contents=content
-            )
-
-            markdown_content = response.text if hasattr(response, 'text') else ''
-
-            return {
-                'file': str(file_path),
-                'status': 'success',
-                'markdown': markdown_content
-            }
-
-        except Exception as e:
-            if attempt == max_retries - 1:
-                return {
-                    'file': str(file_path),
-                    'status': 'error',
-                    'error': str(e),
-                    'markdown': None
-                }
-
-            wait_time = 2 ** attempt
-            if verbose:
-                print(f"  Retry {attempt + 1} after {wait_time}s: {e}")
-            time.sleep(wait_time)
-
-
-def batch_convert(
-    files: List[str],
-    output_file: Optional[str] = None,
-    auto_name: bool = False,
-    model: str = 'gemini-2.5-flash',
-    custom_prompt: Optional[str] = None,
-    verbose: bool = False
-) -> List[Dict[str, Any]]:
-    """Batch convert multiple files to markdown."""
-
-    api_key = find_api_key()
-    if not api_key:
-        print("Error: GEMINI_API_KEY not found")
-        print("Set via: export GEMINI_API_KEY='your-key'")
-        print("Or create .env file with: GEMINI_API_KEY=your-key")
-        sys.exit(1)
-
-    client = genai.Client(api_key=api_key)
-    results = []
-
-    # Determine output path
-    if not output_file:
-        project_root = find_project_root()
-        output_dir = project_root / 'docs' / 'assets'
-
-        if auto_name and len(files) == 1:
-            # Auto-generate meaningful filename from input
-            input_path = Path(files[0])
-            base_name = input_path.stem
-            output_file = str(output_dir / f"{base_name}-extraction.md")
-        else:
-            output_file = str(output_dir / 'document-extraction.md')
-
-    output_path = Path(output_file)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-
-    # Process each file
-    for i, file_path in enumerate(files, 1):
-        if verbose:
-            print(f"\n[{i}/{len(files)}] Converting: {file_path}")
-
-        result = convert_to_markdown(
-            client=client,
-            file_path=file_path,
-            model=model,
-            custom_prompt=custom_prompt,
-            verbose=verbose
-        )
-
-        results.append(result)
-
-        if verbose:
-            status = result.get('status', 'unknown')
-            print(f"  Status: {status}")
-
-    # Save combined markdown
-    with open(output_path, 'w', encoding='utf-8') as f:
-        f.write("# Document Extraction Results\n\n")
-        f.write(f"Converted {len(files)} document(s) to markdown.\n\n")
-        f.write("---\n\n")
-
-        for result in results:
-            f.write(f"## {Path(result['file']).name}\n\n")
-
-            if result['status'] == 'success' and result.get('markdown'):
-                f.write(result['markdown'])
-                f.write("\n\n")
-            elif result['status'] == 'success':
-                f.write("**Note**: Conversion succeeded but no content was returned.\n\n")
-            else:
-                f.write(f"**Error**: {result.get('error', 'Unknown error')}\n\n")
-
-            f.write("---\n\n")
-
-    if verbose or True:  # Always show output location
-        print(f"\n{'='*50}")
-        print(f"Converted: {len(results)} file(s)")
-        print(f"Success: {sum(1 for r in results if r['status'] == 'success')}")
-        print(f"Failed: {sum(1 for r in results if r['status'] == 'error')}")
-        print(f"Output saved to: {output_path}")
-
-    return results
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Convert documents to Markdown using Gemini API',
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Convert single PDF to markdown (default name)
-  %(prog)s --input document.pdf
-
-  # Auto-generate meaningful filename
-  %(prog)s --input testpdf.pdf --auto-name
-  # Output: docs/assets/testpdf-extraction.md
-
-  # Convert multiple files
-  %(prog)s --input doc1.pdf doc2.docx image.png
-
-  # Specify custom output location
-  %(prog)s --input document.pdf --output ./output.md
-
-  # Use custom prompt
-  %(prog)s --input document.pdf --prompt "Extract only the tables as markdown"
-
-  # Batch convert directory
-  %(prog)s --input ./documents/*.pdf --verbose
-
-Supported formats:
-  - PDF documents (up to 1,000 pages)
-  - Images (JPEG, PNG, WEBP, HEIC)
-  - Office documents (DOCX, XLSX, PPTX)
-  - Text formats (TXT, HTML, Markdown, CSV)
-
-Default output: <project-root>/docs/assets/document-extraction.md
-        """
-    )
-
-    parser.add_argument('--input', '-i', nargs='+', required=True,
-                       help='Input file(s) to convert')
-    parser.add_argument('--output', '-o',
-                       help='Output markdown file (default: docs/assets/document-extraction.md)')
-    parser.add_argument('--auto-name', '-a', action='store_true',
-                       help='Auto-generate meaningful output filename from input (e.g., document.pdf -> document-extraction.md)')
-    parser.add_argument('--model', default='gemini-2.5-flash',
-                       help='Gemini model to use (default: gemini-2.5-flash)')
-    parser.add_argument('--prompt', '-p',
-                       help='Custom prompt for conversion')
-    parser.add_argument('--verbose', '-v', action='store_true',
-                       help='Verbose output')
-
-    args = parser.parse_args()
-
-    # Validate input files
-    files = []
-    for file_pattern in args.input:
-        file_path = Path(file_pattern)
-        if file_path.exists() and file_path.is_file():
-            files.append(str(file_path))
-        else:
-            # Try glob pattern
-            import glob
-            matched = glob.glob(file_pattern)
-            files.extend([f for f in matched if Path(f).is_file()])
-
-    if not files:
-        print("Error: No valid input files found")
-        sys.exit(1)
-
-    # Convert files
-    batch_convert(
-        files=files,
-        output_file=args.output,
-        auto_name=args.auto_name,
-        model=args.model,
-        custom_prompt=args.prompt,
-        verbose=args.verbose
-    )
-
-
-if __name__ == '__main__':
-    main()