geomind-ai 1.1.0__tar.gz → 1.1.1__tar.gz

{geomind_ai-1.1.0 → geomind_ai-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geomind-ai
-Version: 1.1.0
+Version: 1.1.1
 Summary: AI agent for geospatial analysis with Sentinel-2 satellite imagery
 Author: Harsh Shinde, Rajat Shinde
 License-Expression: MIT

{geomind_ai-1.1.0 → geomind_ai-1.1.1}/geomind/agent.py

@@ -263,7 +263,7 @@ class GeoMindAgent:
                 "3. Create .env file with: OPENROUTER_API_KEY=YOUR_KEY"
             )
 
-        print(f"🚀 GeoMind Agent initialized with {self.model_name}")
+        print(f"GeoMind Agent initialized with {self.model_name}")
 
         # Create OpenAI-compatible client
         self.client = OpenAI(base_url=self.base_url, api_key=self.api_key)
@@ -292,10 +292,19 @@ Key information:
 - Bands available: B01-B12 at 10m, 20m, or 60m resolution
 - Current date: {datetime.now().strftime('%Y-%m-%d')}
 
+IMPORTANT - Zarr URL usage:
+- STAC search results include both SR_10m (base URL) and individual band assets (B02_10m, B03_10m, B04_10m, B08_10m)
+- EITHER type of URL works for create_rgb_composite and calculate_ndvi:
+  * SR_10m URL: Points to .../measurements/reflectance/r10m (contains all bands as subdirectories)
+  * Individual band URLs: Point directly to specific bands like .../r10m/b02
+- Prefer using SR_10m URL as it's simpler and works for all bands
+- The processing functions automatically handle the correct path structure
+
 When users ask for imagery:
 1. First use get_bbox_from_location or list_recent_imagery to search
-2. Present the results clearly with key metadata
+2. Present the results clearly with key metadata (ID, date, cloud cover)
 3. Offer to create visualizations if data is found
+4. For visualizations, use the SR_10m asset URL from search results
 
 Always explain what you're doing and interpret results in a helpful way."""
 
@@ -312,7 +321,7 @@ Always explain what you're doing and interpret results in a helpful way."""
 
     def _execute_function(self, name: str, args: dict) -> dict:
         """Execute a function call and return the result."""
-        print(f"  🔧 Executing: {name}({args})")
+        print(f"  Executing: {name}({args})")
 
         if name not in TOOL_FUNCTIONS:
             return {"error": f"Unknown function: {name}"}
@@ -328,8 +337,8 @@ Always explain what you're doing and interpret results in a helpful way."""
         Send a message to the agent and get a response.
         """
         if verbose:
-            print(f"\n💬 User: {message}")
-            print("🤔 Processing...")
+            print(f"\nUser: {message}")
+            print("Processing...")
 
         # Add user message to history
         self.history.append({"role": "user", "content": message})
@@ -395,7 +404,7 @@ Always explain what you're doing and interpret results in a helpful way."""
                 self.history.append({"role": "assistant", "content": final_text})
 
                 if verbose:
-                    print(f"\n🌍 GeoMind: {final_text}")
+                    print(f"\nGeoMind: {final_text}")
 
                 return final_text
 
@@ -404,7 +413,7 @@ Always explain what you're doing and interpret results in a helpful way."""
     def reset(self):
         """Reset the chat session."""
         self.history = []
-        print("🔄 Chat session reset")
+        print("Chat session reset")
 
 
 def main(model: Optional[str] = None):
@@ -412,7 +421,7 @@ def main(model: Optional[str] = None):
     import sys
 
     print("=" * 60)
-    print("🌍 GeoMind - Geospatial AI Agent")
+    print("GeoMind - Geospatial AI Agent")
     print("=" * 60)
     print("Powered by OpenRouter | Sentinel-2 Imagery")
     print("Type 'quit' or 'exit' to end the session")
@@ -422,22 +431,22 @@ def main(model: Optional[str] = None):
     try:
         agent = GeoMindAgent(model=model)
     except ValueError as e:
-        print(f"\n❌ Error: {e}")
+        print(f"\nError: {e}")
         sys.exit(1)
     except Exception as e:
-        print(f"\n❌ Error: {e}")
+        print(f"\nError: {e}")
         print("\nPlease check your API key and internet connection.")
         sys.exit(1)
 
     while True:
         try:
-            user_input = input("\n💬 You: ").strip()
+            user_input = input("\nYou: ").strip()
 
             if not user_input:
                 continue
 
             if user_input.lower() in ["quit", "exit", "q"]:
-                print("\n👋 Goodbye!")
+                print("\nGoodbye!")
                 break
 
             if user_input.lower() == "reset":
@@ -447,10 +456,10 @@ def main(model: Optional[str] = None):
             agent.chat(user_input)
 
         except KeyboardInterrupt:
-            print("\n\n👋 Goodbye!")
+            print("\n\nGoodbye!")
             break
         except Exception as e:
-            print(f"\n❌ Error: {e}")
+            print(f"\nError: {e}")
 
 
 if __name__ == "__main__":

geomind_ai-1.1.1/geomind/cli.py

@@ -0,0 +1,392 @@
+"""
+Command-line interface for GeoMind.
+"""
+
+import sys
+import os
+import argparse
+from pathlib import Path
+from typing import Optional
+import subprocess
+import platform
+import threading
+import time
+
+from .agent import GeoMindAgent
+
+
+# Config file path for storing API key
+CONFIG_DIR = Path.home() / ".geomind"
+CONFIG_FILE = CONFIG_DIR / "config"
+
+
+def get_saved_api_key() -> Optional[str]:
+    """Get API key saved on user's PC."""
+    if CONFIG_FILE.exists():
+        try:
+            return CONFIG_FILE.read_text().strip()
+        except Exception:
+            return None
+    return None
+
+
+def save_api_key(api_key: str) -> bool:
+    """Save API key to user's PC."""
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(api_key)
+        return True
+    except Exception:
+        return False
+
+
+def display_recent_images():
+    """Display recently created images if any exist."""
+    outputs_dir = Path("outputs")
+    if not outputs_dir.exists():
+        return
+    
+    # Get recent image files (created in last few seconds)
+    import time
+    recent_threshold = time.time() - 30  # 30 seconds ago
+    
+    recent_images = []
+    for ext in ['*.png', '*.jpg', '*.jpeg', '*.tiff']:
+        for img_file in outputs_dir.glob(ext):
+            if img_file.stat().st_mtime > recent_threshold:
+                recent_images.append(img_file)
+    
+    if recent_images:
+        print("\n" + "="*60)
+        print("Generated Images:")
+        for img in recent_images:
+            print(f"   • {img.name} ({img.stat().st_size // 1024}KB)")
+        
+        # Try to open the most recent image
+        if recent_images:
+            latest_image = max(recent_images, key=lambda x: x.stat().st_mtime)
+            open_image_viewer(latest_image)
+        print("="*60)
+
+
+def open_image_viewer(image_path: Path):
+    """Open image in default viewer."""
+    try:
+        system = platform.system()
+        if system == "Windows":
+            os.startfile(str(image_path))
+        elif system == "Darwin":  # macOS
+            subprocess.run(["open", str(image_path)], check=False)
+        else:  # Linux
+            subprocess.run(["xdg-open", str(image_path)], check=False)
+        print(f"   -> Opened {image_path.name} in default viewer")
+    except Exception:
+        print(f"   -> Saved to: {image_path}")
+
+
+def format_response_box(title: str, content: str, color_code: str = "\033[94m") -> str:
+    """Format response in an attractive box."""
+    RESET = "\033[0m"
+    lines = content.split('\n')
+    max_width = max(len(line) for line in lines) if lines else 0
+    max_width = max(max_width, len(title) + 4)
+    width = min(max_width + 4, 80)
+    
+    box = f"{color_code}"
+    box += "┌" + "─" * (width - 2) + "┐\n"
+    box += f"│ {title:<{width-4}} │\n"
+    box += "├" + "─" * (width - 2) + "┤\n"
+    
+    for line in lines:
+        if line.strip():
+            box += f"│ {line:<{width-4}} │\n"
+        else:
+            box += f"│{' ' * (width-2)}│\n"
+    
+    box += "└" + "─" * (width - 2) + "┘"
+    box += RESET
+    return box
+
+
+class ThinkingIndicator:
+    """Claude Code style thinking animation."""
+    
+    def __init__(self):
+        self.is_thinking = False
+        self.thread = None
+        self.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+        self.thinking_messages = [
+            "Thinking",
+            "Analyzing satellite data",
+            "Processing request",
+            "Searching imagery"
+        ]
+    
+    def start(self):
+        """Start the thinking animation."""
+        self.is_thinking = True
+        self.thread = threading.Thread(target=self._animate)
+        self.thread.daemon = True
+        self.thread.start()
+    
+    def stop(self):
+        """Stop the thinking animation."""
+        self.is_thinking = False
+        if self.thread:
+            self.thread.join(timeout=0.1)
+        # Clear the line
+        print("\r" + " " * 60 + "\r", end="", flush=True)
+    
+    def _animate(self):
+        """Run the thinking animation."""
+        frame_idx = 0
+        message_idx = 0
+        message_counter = 0
+        
+        # Colors like Claude Code
+        DIM = '\033[2m'
+        RESET = '\033[0m'
+        
+        while self.is_thinking:
+            spinner = self.frames[frame_idx % len(self.frames)]
+            
+            # Cycle through thinking messages every 30 frames (3 seconds)
+            if message_counter % 30 == 0:
+                message_idx = (message_idx + 1) % len(self.thinking_messages)
+            
+            message = self.thinking_messages[message_idx]
+            
+            # Show thinking with shimmer effect like Claude Code
+            print(f"\r{DIM}{spinner} {message}...{RESET}", end="", flush=True)
+            
+            time.sleep(0.1)
+            frame_idx += 1
+            message_counter += 1
+
+
+def main():
+    """Main CLI entry point for the geomind package."""
+    parser = argparse.ArgumentParser(
+        description="GeoMind - AI agent for geospatial analysis with Sentinel-2 imagery",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Interactive mode
+  geomind
+
+  # Single query
+  geomind --query "Find recent imagery of Paris"
+
+  # With custom model
+  geomind --model "anthropic/claude-3.5-sonnet"
+
+  # With API key
+  geomind --api-key "your-openrouter-api-key"
+
+  # Clear saved API key
+  geomind --clear-key
+
+Environment Variables:
+  OPENROUTER_API_KEY    Your OpenRouter API key
+  OPENROUTER_MODEL      Model to use (default: nvidia/nemotron-3-nano-30b-a3b:free)
+  OPENROUTER_API_URL    API endpoint (default: https://openrouter.ai/api/v1)
+        """,
+    )
+
+    parser.add_argument(
+        "--query",
+        "-q",
+        type=str,
+        help="Single query to run (if not provided, starts interactive mode)",
+    )
+    parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        help="Model name to use (e.g., 'anthropic/claude-3.5-sonnet')",
+    )
+    parser.add_argument(
+        "--api-key",
+        "-k",
+        type=str,
+        help="OpenRouter API key (or set OPENROUTER_API_KEY env variable)",
+    )
+    parser.add_argument(
+        "--version", "-v", action="store_true", help="Show version and exit"
+    )
+    parser.add_argument("--clear-key", action="store_true", help="Clear saved API key")
+
+    args = parser.parse_args()
+
+    if args.clear_key:
+        if CONFIG_FILE.exists():
+            CONFIG_FILE.unlink()
+            print("Saved API key cleared.")
+        else:
+            print("No saved API key found.")
+        sys.exit(0)
+
+    if args.version:
+        from . import __version__
+
+        print(f"GeoMind version {__version__}")
+        sys.exit(0)
+
+    # Start interactive or single-query mode
+    try:
+        if args.query:
+            # Single query mode - check API key in order: argument > env > saved file
+            from .config import OPENROUTER_API_KEY
+            
+            api_key = args.api_key or OPENROUTER_API_KEY or get_saved_api_key()
+            if not api_key:
+                print("Error: No API key found. Run 'geomind' first to set up.")
+                sys.exit(1)
+            agent = GeoMindAgent(model=args.model, api_key=api_key)
+            agent.chat(args.query)
+        else:
+            # Interactive mode
+            run_interactive(model=args.model, api_key=args.api_key)
+    except ValueError as e:
+        print(f"\nError: {e}")
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\n\nGoodbye!")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\nUnexpected error: {e}")
+        sys.exit(1)
+
+
+def print_banner():
+    from . import __version__
+    
+    # ANSI color codes
+    BOLD = '\033[1m'
+    DIM = '\033[2m'
+    RESET = '\033[0m'
+    
+    banner = f"""
+┌──────────────────────────────────────────────────────────────────────┐
+│ {BOLD}>_ GeoMind{RESET} (v{__version__})                                                  │
+│                                                                      │
+│ model:     nvidia/nemotron-3-nano-30b-a3b:free                       │
+│ docs:      https://harshshinde0.github.io/GeoMind                    │
+│ authors:   Harsh Shinde, Rajat Shinde                                │
+│ official:  https://harshshinde0.github.io/GeoMind                    │
+│                                                                      │
+│ Type "?" for help, "quit" to exit.                                   │
+└──────────────────────────────────────────────────────────────────────┘
+"""
+    print(banner)
+    print()
+
+
+def print_help():
+    """Print interactive session help."""
+    help_text = """
+Interactive Commands:
+  help, ?          Show this help
+  reset            Reset conversation
+  exit, quit, q    Exit GeoMind
+
+Query Examples:
+  > Find recent Sentinel-2 imagery of Paris
+  > Show me NDVI data for the Amazon rainforest  
+  > Search for images with less than 10% cloud cover in London
+  > Get satellite data for coordinates 40.7128, -74.0060
+
+For CLI options, run: geomind --help
+    """
+    print(help_text)
+
+
+def run_interactive(model: Optional[str] = None, api_key: Optional[str] = None):
+    """Run interactive CLI mode."""
+    from . import __version__
+
+    print_banner()
+
+    # Check for API key in order: argument > env > saved file
+    from .config import OPENROUTER_API_KEY
+
+    # Priority: command line arg > env variable > saved file
+    if api_key:
+        # Use provided argument
+        pass
+    elif OPENROUTER_API_KEY:
+        api_key = OPENROUTER_API_KEY
+    else:
+        api_key = get_saved_api_key()
+
+    if not api_key:
+        print("\nOpenRouter API key required (FREE)")
+        print("   Get yours at: https://openrouter.ai/settings/keys\n")
+        api_key = input("   Enter your API key: ").strip()
+
+        if not api_key:
+            print("\nNo API key provided. Exiting.")
+            return
+
+        # Save the key for future use
+        if save_api_key(api_key):
+            print("   API key saved! You won't need to enter it again.\n")
+        else:
+            print("   Warning: Could not save API key. You'll need to enter it next time.\n")
+
+    agent = GeoMindAgent(model=model, api_key=api_key)
+
+    # Claude Code style color scheme
+    CYAN = '\033[96m'
+    DIM = '\033[2m' 
+    BOLD = '\033[1m'
+    RESET = '\033[0m'
+
+    while True:
+        try:
+            # Simple prompt like Claude Code
+            user_input = input(f"\n{CYAN}>{RESET} ").strip()
+
+            if not user_input:
+                continue
+
+            if user_input.lower() in ["quit", "exit", "q"]:
+                print(f"\n{DIM}Goodbye!{RESET}")
+                break
+
+            if user_input.lower() == "reset":
+                agent.reset()
+                print(f"{DIM}Started new conversation{RESET}")
+                continue
+
+            if user_input.lower() in ["help", "?"]:
+                print_help()
+                continue
+
+            # Start thinking animation
+            thinking = ThinkingIndicator()
+            thinking.start()
+            
+            try:
+                # Get response from agent
+                response = agent.chat(user_input, verbose=False)
+                
+                # Stop thinking animation
+                thinking.stop()
+                
+                # Display response cleanly like Claude Code
+                print(f"\n{response}")
+                
+            except Exception as chat_error:
+                thinking.stop()
+                raise chat_error
+
+        except KeyboardInterrupt:
+            print(f"\n\n{DIM}Goodbye!{RESET}")
+            break
+        except Exception as e:
+            print(f"\n{DIM}Error: {e}{RESET}")
+
+
+if __name__ == "__main__":
+    main()

{geomind_ai-1.1.0 → geomind_ai-1.1.1}/geomind/tools/processing.py

@@ -106,7 +106,7 @@ def create_rgb_composite(
     Uses B04 (Red), B03 (Green), B02 (Blue) bands.
 
     Args:
-        zarr_url: URL to the SR_10m Zarr asset
+        zarr_url: URL to the SR_10m Zarr asset or individual band asset URL
         output_path: Optional path to save the image
         subset_size: Size to subset the image (for faster processing)
 
@@ -117,15 +117,23 @@ def create_rgb_composite(
         import xarray as xr
         import zarr
 
-        # Open the Zarr store
-        # The SR_10m asset contains b02, b03, b04, b08
-        store = zarr.open(zarr_url, mode="r")
-
-        # Read the bands
-        # Note: Band names are lowercase in the Zarr structure
-        red = np.array(store["b04"])
-        green = np.array(store["b03"])
-        blue = np.array(store["b02"])
+        # Determine if this is a band-specific URL or base SR_10m URL
+        # Band-specific URLs end with /b02, /b03, /b04, etc.
+        # Base SR_10m URLs end with /r10m
+        is_band_url = zarr_url.rstrip('/').split('/')[-1].startswith('b')
+        
+        if is_band_url:
+            # Individual band URL provided - need to construct URLs for each band
+            base_url = '/'.join(zarr_url.rstrip('/').split('/')[:-1])
+            red = np.array(zarr.open(f"{base_url}/b04", mode="r"))
+            green = np.array(zarr.open(f"{base_url}/b03", mode="r"))
+            blue = np.array(zarr.open(f"{base_url}/b02", mode="r"))
+        else:
+            # Base SR_10m URL - bands are subdirectories
+            base_url = zarr_url.rstrip('/')
+            red = np.array(zarr.open(f"{base_url}/b04", mode="r"))
+            green = np.array(zarr.open(f"{base_url}/b03", mode="r"))
+            blue = np.array(zarr.open(f"{base_url}/b02", mode="r"))
 
         # Subset if requested (for faster processing)
         if subset_size and red.shape[0] > subset_size:
@@ -197,7 +205,7 @@ def calculate_ndvi(
     Uses B08 (NIR) and B04 (Red) bands.
 
     Args:
-        zarr_url: URL to the SR_10m Zarr asset
+        zarr_url: URL to the SR_10m Zarr asset or individual band asset URL
         output_path: Optional path to save the NDVI image
         subset_size: Size to subset the image
 
@@ -208,12 +216,19 @@ def calculate_ndvi(
         import zarr
         from matplotlib.colors import LinearSegmentedColormap
 
-        # Open the Zarr store
-        store = zarr.open(zarr_url, mode="r")
-
-        # Read the bands
-        nir = np.array(store["b08"])  # NIR
-        red = np.array(store["b04"])  # Red
+        # Determine if this is a band-specific URL or base SR_10m URL
+        is_band_url = zarr_url.rstrip('/').split('/')[-1].startswith('b')
+        
+        if is_band_url:
+            # Individual band URL provided
+            base_url = '/'.join(zarr_url.rstrip('/').split('/')[:-1])
+            nir = np.array(zarr.open(f"{base_url}/b08", mode="r"))
+            red = np.array(zarr.open(f"{base_url}/b04", mode="r"))
+        else:
+            # Base SR_10m URL
+            base_url = zarr_url.rstrip('/')
+            nir = np.array(zarr.open(f"{base_url}/b08", mode="r"))
+            red = np.array(zarr.open(f"{base_url}/b04", mode="r"))
 
         # Subset if requested
         if subset_size and nir.shape[0] > subset_size:

{geomind_ai-1.1.0 → geomind_ai-1.1.1}/geomind/tools/stac_search.py

@@ -25,6 +25,24 @@ def _format_item(item) -> dict:
     """Format a STAC item into a simplified dictionary."""
     props = item.properties
 
+    # Extract individual band assets for direct access
+    assets = {}
+    for key, asset in item.assets.items():
+        if key in ["SR_10m", "SR_20m", "SR_60m", "TCI_10m", "product"]:
+            assets[key] = {
+                "title": asset.title,
+                "href": asset.href,
+                "type": asset.media_type,
+            }
+        # Include individual 10m band assets for direct access
+        elif key in ["B02_10m", "B03_10m", "B04_10m", "B08_10m"]:
+            assets[key] = {
+                "title": asset.title,
+                "href": asset.href,
+                "type": asset.media_type,
+                "band": key.split("_")[0].lower(),  # Extract band name (b02, b03, b04, b08)
+            }
+
     return {
         "id": item.id,
         "datetime": props.get("datetime"),
@@ -32,15 +50,7 @@ def _format_item(item) -> dict:
         "platform": props.get("platform"),
         "bbox": item.bbox,
         "geometry": item.geometry,
-        "assets": {
-            key: {
-                "title": asset.title,
-                "href": asset.href,
-                "type": asset.media_type,
-            }
-            for key, asset in item.assets.items()
-            if key in ["SR_10m", "SR_20m", "SR_60m", "TCI_10m", "product"]
-        },
+        "assets": assets,
         "stac_url": f"{STAC_API_URL}/collections/{STAC_COLLECTION}/items/{item.id}",
     }
 

{geomind_ai-1.1.0 → geomind_ai-1.1.1}/geomind_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geomind-ai
-Version: 1.1.0
+Version: 1.1.1
 Summary: AI agent for geospatial analysis with Sentinel-2 satellite imagery
 Author: Harsh Shinde, Rajat Shinde
 License-Expression: MIT

{geomind_ai-1.1.0 → geomind_ai-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "geomind-ai"
-version = "1.1.0"
+version = "1.1.1"
 description = "AI agent for geospatial analysis with Sentinel-2 satellite imagery"
 readme = "README.md"
 authors = [

geomind_ai-1.1.0/geomind/cli.py

@@ -1,199 +0,0 @@
-"""
-Command-line interface for GeoMind.
-"""
-
-import sys
-import os
-import argparse
-from pathlib import Path
-from typing import Optional
-
-from .agent import GeoMindAgent
-
-
-# Config file path for storing API key
-CONFIG_DIR = Path.home() / ".geomind"
-CONFIG_FILE = CONFIG_DIR / "config"
-
-
-def get_saved_api_key() -> Optional[str]:
-    """Get API key saved on user's PC."""
-    if CONFIG_FILE.exists():
-        try:
-            return CONFIG_FILE.read_text().strip()
-        except Exception:
-            return None
-    return None
-
-
-def save_api_key(api_key: str) -> bool:
-    """Save API key to user's PC."""
-    try:
-        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
-        CONFIG_FILE.write_text(api_key)
-        return True
-    except Exception:
-        return False
-
-
-def main():
-    """Main CLI entry point for the geomind package."""
-    parser = argparse.ArgumentParser(
-        description="GeoMind - AI agent for geospatial analysis with Sentinel-2 imagery",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Interactive mode
-  geomind
-
-  # Single query
-  geomind --query "Find recent imagery of Paris"
-
-  # With custom model
-  geomind --model "anthropic/claude-3.5-sonnet"
-
-  # With API key
-  geomind --api-key "your-openrouter-api-key"
-
-  # Clear saved API key
-  geomind --clear-key
-
-Environment Variables:
-  OPENROUTER_API_KEY    Your OpenRouter API key
-  OPENROUTER_MODEL      Model to use (default: nvidia/nemotron-3-nano-30b-a3b:free)
-  OPENROUTER_API_URL    API endpoint (default: https://openrouter.ai/api/v1)
-        """,
-    )
-
-    parser.add_argument(
-        "--query",
-        "-q",
-        type=str,
-        help="Single query to run (if not provided, starts interactive mode)",
-    )
-    parser.add_argument(
-        "--model",
-        "-m",
-        type=str,
-        help="Model name to use (e.g., 'anthropic/claude-3.5-sonnet')",
-    )
-    parser.add_argument(
-        "--api-key",
-        "-k",
-        type=str,
-        help="OpenRouter API key (or set OPENROUTER_API_KEY env variable)",
-    )
-    parser.add_argument(
-        "--version", "-v", action="store_true", help="Show version and exit"
-    )
-    parser.add_argument("--clear-key", action="store_true", help="Clear saved API key")
-
-    args = parser.parse_args()
-
-    if args.clear_key:
-        if CONFIG_FILE.exists():
-            CONFIG_FILE.unlink()
-            print("✅ Saved API key cleared.")
-        else:
-            print("ℹ️ No saved API key found.")
-        sys.exit(0)
-
-    if args.version:
-        from . import __version__
-
-        print(f"GeoMind version {__version__}")
-        sys.exit(0)
-
-    # Start interactive or single-query mode
-    try:
-        if args.query:
-            # Single query mode - check API key in order: argument > env > saved file
-            from .config import OPENROUTER_API_KEY
-            
-            api_key = args.api_key or OPENROUTER_API_KEY or get_saved_api_key()
-            if not api_key:
-                print("❌ No API key found. Run 'geomind' first to set up.")
-                sys.exit(1)
-            agent = GeoMindAgent(model=args.model, api_key=api_key)
-            agent.chat(args.query)
-        else:
-            # Interactive mode
-            run_interactive(model=args.model, api_key=args.api_key)
-    except ValueError as e:
-        print(f"\n❌ Error: {e}")
-        sys.exit(1)
-    except KeyboardInterrupt:
-        print("\n\n👋 Goodbye!")
-        sys.exit(0)
-    except Exception as e:
-        print(f"\n❌ Unexpected error: {e}")
-        sys.exit(1)
-
-
-def run_interactive(model: Optional[str] = None, api_key: Optional[str] = None):
-    """Run interactive CLI mode."""
-    from . import __version__
-
-    print("=" * 60)
-    print("🌍 GeoMind - Geospatial AI Agent")
-    print("=" * 60)
-    print(f"Version: {__version__} | Authors: Harsh Shinde, Rajat Shinde")
-    print("Type 'quit' or 'exit' to end the session")
-    print("Type 'reset' to start a new conversation")
-    print("Type 'geomind --help' for more options")
-
-    # Check for API key in order: argument > env > saved file
-    from .config import OPENROUTER_API_KEY
-
-    # Priority: command line arg > env variable > saved file
-    if api_key:
-        # Use provided argument
-        pass
-    elif OPENROUTER_API_KEY:
-        api_key = OPENROUTER_API_KEY
-    else:
-        api_key = get_saved_api_key()
-
-    if not api_key:
-        print("\n🔑 OpenRouter API key required (FREE)")
-        print("   Get yours at: https://openrouter.ai/settings/keys\n")
-        api_key = input("   Enter your API key: ").strip()
-
-        if not api_key:
-            print("\n❌ No API key provided. Exiting.")
-            return
-
-        # Save the key for future use
-        if save_api_key(api_key):
-            print("   ✅ API key saved! You won't need to enter it again.\n")
-        else:
-            print("   ⚠️ Could not save API key. You'll need to enter it next time.\n")
-
-    agent = GeoMindAgent(model=model, api_key=api_key)
-
-    while True:
-        try:
-            user_input = input("\n💬 You: ").strip()
-
-            if not user_input:
-                continue
-
-            if user_input.lower() in ["quit", "exit", "q"]:
-                print("\n👋 Goodbye!")
-                break
-
-            if user_input.lower() == "reset":
-                agent.reset()
-                continue
-
-            agent.chat(user_input)
-
-        except KeyboardInterrupt:
-            print("\n\n👋 Goodbye!")
-            break
-        except Exception as e:
-            print(f"\n❌ Error: {e}")
-
-
-if __name__ == "__main__":
-    main()