geomind-ai 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

geomind/__init__.py

@@ -3,7 +3,7 @@ GeoMind - Geospatial AI Agent
 
 """
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 __author__ = "Harsh Shinde, Rajat Shinde"
 
 from .agent import GeoMindAgent

geomind/agent.py

@@ -1,144 +1,50 @@
 """
-GeoMind Agent - Main agent class powered by OpenRouter.
-
-This module implements the AI agent that can understand natural language
-queries about satellite imagery and execute the appropriate tools.
+GeoMind Agent - Simplified AI agent for satellite imagery analysis.
 """
 
 import json
-import re
-from typing import Optional, Callable, Any
+from typing import Optional
 from datetime import datetime
-
 from openai import OpenAI
 
-from .config import (
-    OPENROUTER_API_KEY,
-    OPENROUTER_API_URL,
-    OPENROUTER_MODEL,
-)
+from .config import OPENROUTER_API_KEY, OPENROUTER_API_URL, OPENROUTER_MODEL
 from .tools import (
-    geocode_location,
-    get_bbox_from_location,
-    search_imagery,
-    get_item_details,
     list_recent_imagery,
     create_rgb_composite,
     calculate_ndvi,
+    search_imagery,
+    get_bbox_from_location,
+    geocode_location,
+    get_item_details,
     get_band_statistics,
 )
 
-
-# Map tool names to functions
+# Tool function mapping
 TOOL_FUNCTIONS = {
-    "geocode_location": geocode_location,
-    "get_bbox_from_location": get_bbox_from_location,
-    "search_imagery": search_imagery,
     "list_recent_imagery": list_recent_imagery,
-    "get_item_details": get_item_details,
     "create_rgb_composite": create_rgb_composite,
     "calculate_ndvi": calculate_ndvi,
+    "search_imagery": search_imagery,
+    "get_bbox_from_location": get_bbox_from_location,
+    "geocode_location": geocode_location,
+    "get_item_details": get_item_details,
     "get_band_statistics": get_band_statistics,
 }
 
-# Tool definitions for the LLM
+# Simplified tool definitions
 TOOLS = [
-    {
-        "type": "function",
-        "function": {
-            "name": "geocode_location",
-            "description": "Convert a place name to geographic coordinates (latitude, longitude). Use this when you need to find coordinates for a location.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "place_name": {
-                        "type": "string",
-                        "description": "The name of the place to geocode (e.g., 'New York City', 'Paris, France')",
-                    }
-                },
-                "required": ["place_name"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "get_bbox_from_location",
-            "description": "Get a bounding box for a location, suitable for searching satellite imagery.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "place_name": {
-                        "type": "string",
-                        "description": "The name of the place",
-                    },
-                    "buffer_km": {
-                        "type": "number",
-                        "description": "Buffer distance in kilometers (default: 10)",
-                    },
-                },
-                "required": ["place_name"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "search_imagery",
-            "description": "Search for Sentinel-2 satellite imagery in the EOPF catalog. Returns available scenes.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "bbox": {
-                        "type": "array",
-                        "items": {"type": "number"},
-                        "description": "Bounding box as [min_lon, min_lat, max_lon, max_lat]",
-                    },
-                    "start_date": {
-                        "type": "string",
-                        "description": "Start date in YYYY-MM-DD format",
-                    },
-                    "end_date": {
-                        "type": "string",
-                        "description": "End date in YYYY-MM-DD format",
-                    },
-                    "max_cloud_cover": {
-                        "type": "number",
-                        "description": "Maximum cloud cover percentage (0-100)",
-                    },
-                    "max_items": {
-                        "type": "integer",
-                        "description": "Maximum number of results",
-                    },
-                },
-                "required": [],
-            },
-        },
-    },
     {
         "type": "function",
         "function": {
             "name": "list_recent_imagery",
-            "description": "List recent Sentinel-2 imagery for a location. Combines geocoding and search.",
+            "description": "Find recent Sentinel-2 imagery for a location",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "location_name": {
-                        "type": "string",
-                        "description": "Name of the location to search",
-                    },
-                    "days": {
-                        "type": "integer",
-                        "description": "Number of days to look back (default: 7)",
-                    },
-                    "max_cloud_cover": {
-                        "type": "number",
-                        "description": "Maximum cloud cover percentage",
-                    },
-                    "max_items": {
-                        "type": "integer",
-                        "description": "Maximum number of results",
-                    },
+                    "location_name": {"type": "string", "description": "Location name"},
+                    "days": {"type": "integer", "description": "Days to look back (default: 14)"},
+                    "max_cloud_cover": {"type": "number", "description": "Max cloud cover %"},
+                    "max_items": {"type": "integer", "description": "Max results"},
                 },
                 "required": [],
             },
@@ -147,37 +53,30 @@ TOOLS = [
     {
         "type": "function",
         "function": {
-            "name": "get_item_details",
-            "description": "Get detailed information about a specific Sentinel-2 scene by its ID.",
+            "name": "create_rgb_composite",
+            "description": "Create RGB composite from Sentinel-2 data",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "item_id": {"type": "string", "description": "The STAC item ID"}
+                    "zarr_url": {"type": "string", "description": "SR_10m Zarr URL"},
+                    "location_name": {"type": "string", "description": "Location for title"},
+                    "subset_size": {"type": "integer", "description": "Image size (default: 1000)"},
                 },
-                "required": ["item_id"],
+                "required": ["zarr_url"],
             },
         },
     },
     {
         "type": "function",
         "function": {
-            "name": "create_rgb_composite",
-            "description": "Create an RGB true-color composite image from Sentinel-2 data.",
+            "name": "calculate_ndvi",
+            "description": "Calculate NDVI vegetation index",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "zarr_url": {
-                        "type": "string",
-                        "description": "URL to the SR_10m Zarr asset from a STAC item",
-                    },
-                    "output_path": {
-                        "type": "string",
-                        "description": "Optional path to save the output image",
-                    },
-                    "subset_size": {
-                        "type": "integer",
-                        "description": "Size to subset the image (default: 1000 pixels)",
-                    },
+                    "zarr_url": {"type": "string", "description": "SR_10m Zarr URL"},
+                    "location_name": {"type": "string", "description": "Location for title"},
+                    "subset_size": {"type": "integer", "description": "Image size (default: 1000)"},
                 },
                 "required": ["zarr_url"],
             },
@@ -186,47 +85,33 @@ TOOLS = [
     {
         "type": "function",
         "function": {
-            "name": "calculate_ndvi",
-            "description": "Calculate NDVI (vegetation index) from Sentinel-2 data.",
+            "name": "search_imagery",
+            "description": "Search Sentinel-2 imagery by parameters",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "zarr_url": {
-                        "type": "string",
-                        "description": "URL to the SR_10m Zarr asset",
-                    },
-                    "output_path": {
-                        "type": "string",
-                        "description": "Optional path to save the NDVI image",
-                    },
-                    "subset_size": {
-                        "type": "integer",
-                        "description": "Size to subset the image",
-                    },
+                    "bbox": {"type": "array", "items": {"type": "number"}, "description": "Bounding box"},
+                    "start_date": {"type": "string", "description": "Start date YYYY-MM-DD"},
+                    "end_date": {"type": "string", "description": "End date YYYY-MM-DD"},
+                    "max_cloud_cover": {"type": "number", "description": "Max cloud cover %"},
+                    "max_items": {"type": "integer", "description": "Max results"},
                 },
-                "required": ["zarr_url"],
+                "required": [],
             },
         },
     },
     {
         "type": "function",
         "function": {
-            "name": "get_band_statistics",
-            "description": "Get statistics (min, max, mean) for spectral bands.",
+            "name": "get_bbox_from_location",
+            "description": "Get bounding box for a location",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "zarr_url": {
-                        "type": "string",
-                        "description": "URL to the Zarr asset",
-                    },
-                    "bands": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "description": "List of band names to analyze",
-                    },
+                    "place_name": {"type": "string", "description": "Location name"},
+                    "buffer_km": {"type": "number", "description": "Buffer distance in km"},
                 },
-                "required": ["zarr_url"],
+                "required": ["place_name"],
             },
         },
     },
@@ -234,224 +119,100 @@ TOOLS = [
 
 
 class GeoMindAgent:
-    """
-    GeoMind - An AI agent for geospatial analysis with Sentinel-2 imagery.
-
-    Uses OpenRouter API for access to multiple AI models.
-    """
+    """Simplified GeoMind agent for satellite imagery analysis."""
 
     def __init__(self, model: Optional[str] = None, api_key: Optional[str] = None):
-        """
-        Initialize the GeoMind agent.
-
-        Args:
-            model: Model name (default: nvidia/nemotron-3-nano-30b-a3b:free)
-            api_key: OpenRouter API key (required).
-        """
-        self.provider = "openrouter"
         self.api_key = api_key or OPENROUTER_API_KEY
         self.model_name = model or OPENROUTER_MODEL
-        self.base_url = OPENROUTER_API_URL
-
+        
         if not self.api_key:
-            raise ValueError(
-                "OpenRouter API key required.\n"
-                "Get your FREE API key at: https://openrouter.ai/settings/keys\n\n"
-                "Then provide it in one of these ways:\n"
-                "1. Run: geomind --api-key YOUR_KEY\n"
-                "2. Set environment variable: OPENROUTER_API_KEY=YOUR_KEY\n"
-                "3. Create .env file with: OPENROUTER_API_KEY=YOUR_KEY"
-            )
-
-        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)
-
-        # Chat history
+            raise ValueError("OpenRouter API key required")
+            
+        print(f"GeoMind Agent initialized with {self.model_name}")
+        self.client = OpenAI(base_url=OPENROUTER_API_URL, api_key=self.api_key)
         self.history = []
 
-        # Add system message
-        self.system_prompt = self._get_system_prompt()
-
     def _get_system_prompt(self) -> str:
-        """Get the system prompt for the agent."""
-        return f"""You are GeoMind, an expert AI assistant specialized in geospatial analysis 
-and satellite imagery. You help users find, analyze, and visualize Sentinel-2 satellite data 
-from the EOPF (ESA Earth Observation Processing Framework) catalog.
-
-Your capabilities include:
-1. **Search**: Find Sentinel-2 L2A imagery by location, date, and cloud cover
-2. **Geocoding**: Convert place names to coordinates for searching
-3. **Visualization**: Create RGB composites and NDVI maps from imagery
-4. **Analysis**: Calculate spectral indices and band statistics
-
-Key information:
-- Data source: EOPF STAC API (https://stac.core.eopf.eodc.eu)
-- Satellite: Sentinel-2 (L2A surface reflectance products)
-- Bands available: B01-B12 at 10m, 20m, or 60m resolution
-- Current date: {datetime.now().strftime('%Y-%m-%d')}
-
-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
-3. Offer to create visualizations if data is found
-
-Always explain what you're doing and interpret results in a helpful way."""
-
-    def _call_llm(self, messages: list, tools: list) -> dict:
-        """Call LLM via OpenAI-compatible client."""
-        response = self.client.chat.completions.create(
-            model=self.model_name,
-            messages=messages,
-            tools=tools,
-            tool_choice="auto",
-            max_tokens=4096,
-        )
-        return response.model_dump()
+        """Short, focused system prompt."""
+        return f"""You are GeoMind, an AI assistant for satellite imagery analysis using Sentinel-2 data.
 
-    def _execute_function(self, name: str, args: dict) -> dict:
-        """Execute a function call and return the result."""
-        print(f"  🔧 Executing: {name}({args})")
+Current date: {datetime.now().strftime('%Y-%m-%d')}
 
-        if name not in TOOL_FUNCTIONS:
-            return {"error": f"Unknown function: {name}"}
+KEY RULES:
+1. Use list_recent_imagery to find satellite data for locations
+2. Extract Zarr URLs from results: item['zarr_assets']['SR_10m']['href'] 
+3. Always include location_name parameter when creating images
+4. Use actual function response data in your answers (don't make up paths/stats)
+5. Let functions use default output paths (saves to outputs/ folder as .png)
 
-        try:
-            result = TOOL_FUNCTIONS[name](**args)
-            return result
-        except Exception as e:
-            return {"error": str(e)}
+Be helpful and accurate - always use real data from function responses."""
 
     def chat(self, message: str, verbose: bool = True) -> str:
-        """
-        Send a message to the agent and get a response.
-        """
+        """Send message to agent and get 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})
+        messages = [{"role": "system", "content": self._get_system_prompt()}] + self.history
+
+        for _ in range(10):  # Max 10 iterations
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                tools=TOOLS,
+                tool_choice="auto",
+                max_tokens=4096,
+            )
 
-        # Build messages with system prompt
-        messages = [{"role": "system", "content": self.system_prompt}] + self.history
-
-        max_iterations = 10
-        iteration = 0
-
-        while iteration < max_iterations:
-            iteration += 1
-
-            # Call the model (via proxy or direct)
-            response_data = self._call_llm(messages, TOOLS)
-
-            # Extract assistant message from response
-            choice = response_data["choices"][0]
-            assistant_message = choice["message"]
+            choice = response.choices[0]
+            assistant_message = choice.message
 
-            # Check if there are tool calls
-            tool_calls = assistant_message.get("tool_calls", [])
+            tool_calls = assistant_message.tool_calls
             if tool_calls:
-                # Add assistant message with tool calls to messages
-                messages.append(
-                    {
-                        "role": "assistant",
-                        "content": assistant_message.get("content") or "",
-                        "tool_calls": [
-                            {
-                                "id": tc["id"],
-                                "type": "function",
-                                "function": {
-                                    "name": tc["function"]["name"],
-                                    "arguments": tc["function"]["arguments"],
-                                },
-                            }
-                            for tc in tool_calls
-                        ],
-                    }
-                )
-
-                # Execute each tool call
-                for tool_call in tool_calls:
-                    func_name = tool_call["function"]["name"]
-                    func_args = json.loads(tool_call["function"]["arguments"])
-
-                    result = self._execute_function(func_name, func_args)
-
-                    # Add tool result to messages
-                    messages.append(
+                # Add assistant message with tool calls
+                messages.append({
+                    "role": "assistant",
+                    "content": assistant_message.content or "",
+                    "tool_calls": [
                         {
-                            "role": "tool",
-                            "tool_call_id": tool_call["id"],
-                            "content": json.dumps(result, default=str),
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {"name": tc.function.name, "arguments": tc.function.arguments},
                         }
-                    )
-            else:
-                # No tool calls, we have a final response
-                final_text = assistant_message.get("content") or ""
+                        for tc in tool_calls
+                    ],
+                })
 
-                # Add to history
+                # Execute tool calls
+                for tool_call in tool_calls:
+                    func_name = tool_call.function.name
+                    func_args = json.loads(tool_call.function.arguments)
+                    
+                    print(f"  Executing: {func_name}({func_args})")
+                    
+                    try:
+                        result = TOOL_FUNCTIONS[func_name](**func_args)
+                    except Exception as e:
+                        result = {"error": str(e)}
+
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": json.dumps(result, default=str),
+                    })
+            else:
+                # Final response
+                final_text = assistant_message.content or ""
                 self.history.append({"role": "assistant", "content": final_text})
-
+                
                 if verbose:
-                    print(f"\n🌍 GeoMind: {final_text}")
-
+                    print(f"\nGeoMind: {final_text}")
+                    
                 return final_text
 
-        return "Max iterations reached."
+        return "Max iterations reached"
 
     def reset(self):
-        """Reset the chat session."""
+        """Reset chat history."""
         self.history = []
-        print("🔄 Chat session reset")
-
-
-def main(model: Optional[str] = None):
-    """Main entry point for CLI usage."""
-    import sys
-
-    print("=" * 60)
-    print("🌍 GeoMind - Geospatial AI Agent")
-    print("=" * 60)
-    print("Powered by OpenRouter | Sentinel-2 Imagery")
-    print("Type 'quit' or 'exit' to end the session")
-    print("Type 'reset' to start a new conversation")
-    print("=" * 60)
-
-    try:
-        agent = GeoMindAgent(model=model)
-    except ValueError as e:
-        print(f"\n❌ Error: {e}")
-        sys.exit(1)
-    except Exception as e:
-        print(f"\n❌ Error: {e}")
-        print("\nPlease check your API key and internet connection.")
-        sys.exit(1)
-
-    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()

geomind/cli.py

@@ -7,6 +7,10 @@ import os
 import argparse
 from pathlib import Path
 from typing import Optional
+import subprocess
+import platform
+import threading
+import time
 
 from .agent import GeoMindAgent
 
@@ -36,6 +40,130 @@ def save_api_key(api_key: str) -> bool:
         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(
@@ -93,9 +221,9 @@ Environment Variables:
     if args.clear_key:
         if CONFIG_FILE.exists():
             CONFIG_FILE.unlink()
-            print("✅ Saved API key cleared.")
+            print("Saved API key cleared.")
         else:
-            print("ℹ️ No saved API key found.")
+            print("No saved API key found.")
         sys.exit(0)
 
     if args.version:
@@ -112,7 +240,7 @@ Environment Variables:
             
             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.")
+                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)
@@ -120,27 +248,64 @@ Environment Variables:
             # Interactive mode
             run_interactive(model=args.model, api_key=args.api_key)
     except ValueError as e:
-        print(f"\n❌ Error: {e}")
+        print(f"\nError: {e}")
         sys.exit(1)
     except KeyboardInterrupt:
-        print("\n\n👋 Goodbye!")
+        print("\n\nGoodbye!")
         sys.exit(0)
     except Exception as e:
-        print(f"\n❌ Unexpected error: {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("=" * 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")
+    print_banner()
 
     # Check for API key in order: argument > env > saved file
     from .config import OPENROUTER_API_KEY
@@ -155,44 +320,72 @@ def run_interactive(model: Optional[str] = None, api_key: Optional[str] = None):
         api_key = get_saved_api_key()
 
     if not api_key:
-        print("\n🔑 OpenRouter API key required (FREE)")
+        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("\n❌ No API key provided. Exiting.")
+            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")
+            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")
+            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:
-            user_input = input("\n💬 You: ").strip()
+            # 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("\n👋 Goodbye!")
+                print(f"\n{DIM}Goodbye!{RESET}")
                 break
 
             if user_input.lower() == "reset":
                 agent.reset()
+                print(f"{DIM}Started new conversation{RESET}")
                 continue
 
-            agent.chat(user_input)
+            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("\n\n👋 Goodbye!")
+            print(f"\n\n{DIM}Goodbye!{RESET}")
             break
         except Exception as e:
-            print(f"\n❌ Error: {e}")
+            print(f"\n{DIM}Error: {e}{RESET}")
 
 
 if __name__ == "__main__":

geomind/config.py

@@ -37,9 +37,9 @@ REFLECTANCE_OFFSET = -0.1
 RGB_BANDS = {"red": "b04", "green": "b03", "blue": "b02"}
 
 # Default search parameters
-DEFAULT_MAX_CLOUD_COVER = 20  # percent
-DEFAULT_BUFFER_KM = 10  # km buffer around point for bbox
-DEFAULT_MAX_ITEMS = 10
+DEFAULT_MAX_CLOUD_COVER = 50  # percent (increased for better results)
+DEFAULT_BUFFER_KM = 15  # km buffer around point for bbox (increased coverage)
+DEFAULT_MAX_ITEMS = 20  # increased to find more options
 
 # Output directory for saved images
 OUTPUT_DIR = Path("outputs")

geomind/tools/processing.py

@@ -99,6 +99,7 @@ def create_rgb_composite(
     zarr_url: str,
     output_path: Optional[str] = None,
     subset_size: Optional[int] = 1000,
+    location_name: Optional[str] = None,
 ) -> dict:
     """
     Create an RGB composite image from Sentinel-2 10m bands.
@@ -106,9 +107,10 @@ 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)
+        location_name: Optional location name to include in the title
 
     Returns:
         Dictionary with path to saved image and metadata
@@ -116,30 +118,49 @@ def create_rgb_composite(
     try:
         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"])
+        import re
+
+        # Determine if this is a band-specific URL or base SR_10m URL
+        # Band-specific URLs end with /b01, /b02, etc. (Sentinel-2 band pattern)
+        url_parts = zarr_url.rstrip('/').split('/')
+        last_part = url_parts[-1]
+        is_band_url = re.match(r'^b(0[1-9]|1[0-2]|8a)(_\d+m)?$', last_part.lower()) is not None
+        
+        if is_band_url:
+            # Individual band URL provided - need to construct URLs for each band
+            base_url = '/'.join(zarr_url.rstrip('/').split('/')[:-1])
+            red_zarr = zarr.open(f"{base_url}/b04", mode="r")
+            green_zarr = zarr.open(f"{base_url}/b03", mode="r")
+            blue_zarr = zarr.open(f"{base_url}/b02", mode="r")
+        else:
+            # Base SR_10m URL - bands are subdirectories
+            base_url = zarr_url.rstrip('/')
+            red_zarr = zarr.open(f"{base_url}/b04", mode="r")
+            green_zarr = zarr.open(f"{base_url}/b03", mode="r")
+            blue_zarr = zarr.open(f"{base_url}/b02", mode="r")
+
+        # Determine subset region before loading data
+        full_shape = red_zarr.shape
+        if subset_size and full_shape[0] > subset_size:
+            # Calculate center subset
+            h, w = full_shape
+            start_h = (h - subset_size) // 2
+            start_w = (w - subset_size) // 2
+            
+            # Load only the subset (memory efficient)
+            red = np.array(red_zarr[start_h:start_h + subset_size, start_w:start_w + subset_size])
+            green = np.array(green_zarr[start_h:start_h + subset_size, start_w:start_w + subset_size])
+            blue = np.array(blue_zarr[start_h:start_h + subset_size, start_w:start_w + subset_size])
+        else:
+            # Load full arrays (be careful with large datasets)
+            red = np.array(red_zarr)
+            green = np.array(green_zarr)
+            blue = np.array(blue_zarr)
 
         # Subset if requested (for faster processing)
         if subset_size and red.shape[0] > subset_size:
-            # Take center subset
-            h, w = red.shape
-            start_h = (h - subset_size) // 2
-            start_w = (w - subset_size) // 2
-            red = red[start_h : start_h + subset_size, start_w : start_w + subset_size]
-            green = green[
-                start_h : start_h + subset_size, start_w : start_w + subset_size
-            ]
-            blue = blue[
-                start_h : start_h + subset_size, start_w : start_w + subset_size
-            ]
+            # Already subsetted during loading - this section can be removed
+            pass
 
         # Apply scale and offset
         red = _apply_scale_offset(red)
@@ -163,7 +184,12 @@ def create_rgb_composite(
         # Create figure
         fig, ax = plt.subplots(figsize=(10, 10))
         ax.imshow(rgb)
-        ax.set_title("Sentinel-2 RGB Composite (B4/B3/B2)")
+        
+        # Create dynamic title with location
+        title = "Sentinel-2 RGB Composite (B4/B3/B2)"
+        if location_name:
+            title += f" - {location_name}"
+        ax.set_title(title)
         ax.axis("off")
 
         # Save
@@ -189,6 +215,7 @@ def calculate_ndvi(
     zarr_url: str,
     output_path: Optional[str] = None,
     subset_size: Optional[int] = 1000,
+    location_name: Optional[str] = None,
 ) -> dict:
     """
     Calculate NDVI (Normalized Difference Vegetation Index) from Sentinel-2 data.
@@ -197,9 +224,10 @@ 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
+        location_name: Optional location name to include in the title
 
     Returns:
         Dictionary with NDVI statistics and output path
@@ -207,21 +235,40 @@ def calculate_ndvi(
     try:
         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
-
-        # Subset if requested
-        if subset_size and nir.shape[0] > subset_size:
-            h, w = nir.shape
+        import re
+
+        # Determine if this is a band-specific URL or base SR_10m URL
+        url_parts = zarr_url.rstrip('/').split('/')
+        last_part = url_parts[-1]
+        is_band_url = re.match(r'^b(0[1-9]|1[0-2]|8a)(_\d+m)?$', last_part.lower()) is not None
+        
+        if is_band_url:
+            # Individual band URL provided
+            base_url = '/'.join(zarr_url.rstrip('/').split('/')[:-1])
+            nir_zarr = zarr.open(f"{base_url}/b08", mode="r")
+            red_zarr = zarr.open(f"{base_url}/b04", mode="r")
+        else:
+            # Base SR_10m URL
+            base_url = zarr_url.rstrip('/')
+            nir_zarr = zarr.open(f"{base_url}/b08", mode="r")
+            red_zarr = zarr.open(f"{base_url}/b04", mode="r")
+
+        # Determine subset region and load efficiently
+        full_shape = nir_zarr.shape
+        if subset_size and full_shape[0] > subset_size:
+            h, w = full_shape
             start_h = (h - subset_size) // 2
             start_w = (w - subset_size) // 2
-            nir = nir[start_h : start_h + subset_size, start_w : start_w + subset_size]
-            red = red[start_h : start_h + subset_size, start_w : start_w + subset_size]
+            nir = np.array(nir_zarr[start_h:start_h + subset_size, start_w:start_w + subset_size])
+            red = np.array(red_zarr[start_h:start_h + subset_size, start_w:start_w + subset_size])
+        else:
+            nir = np.array(nir_zarr)
+            red = np.array(red_zarr)
+
+        # Subset if requested - already handled during loading
+        if subset_size and nir.shape[0] > subset_size:
+            # Already subsetted during loading
+            pass
 
         # Apply scale and offset
         nir = _apply_scale_offset(nir)
@@ -256,7 +303,12 @@ def calculate_ndvi(
         # Create figure
         fig, ax = plt.subplots(figsize=(10, 10))
         im = ax.imshow(ndvi, cmap=ndvi_cmap, vmin=-1, vmax=1)
-        ax.set_title("NDVI - Normalized Difference Vegetation Index")
+        
+        # Create dynamic title with location
+        title = "NDVI - Normalized Difference Vegetation Index"
+        if location_name:
+            title += f" - {location_name}"
+        ax.set_title(title)
         ax.axis("off")
 
         # Add colorbar

geomind/tools/stac_search.py

@@ -25,6 +25,33 @@ def _format_item(item) -> dict:
     """Format a STAC item into a simplified dictionary."""
     props = item.properties
 
+    # Extract ALL assets, with special handling for Zarr assets
+    assets = {}
+    zarr_assets = {}
+    other_assets = {}
+    
+    for key, asset in item.assets.items():
+        asset_info = {
+            "title": asset.title,
+            "href": asset.href,
+            "type": asset.media_type,
+        }
+        
+        # Add band information for individual band assets
+        if "_" in key and key.split("_")[0] in ["B01", "B02", "B03", "B04", "B05", "B06", "B07", "B08", "B8A", "B09", "B11", "B12"]:
+            band_name = key.split("_")[0].lower()
+            asset_info["band"] = band_name
+            asset_info["resolution"] = key.split("_")[1] if "_" in key else "unknown"
+        
+        # Categorize assets by type
+        if asset.media_type and "zarr" in asset.media_type.lower():
+            zarr_assets[key] = asset_info
+        else:
+            other_assets[key] = asset_info
+        
+        # Include all assets in main assets dict
+        assets[key] = asset_info
+
     return {
         "id": item.id,
         "datetime": props.get("datetime"),
@@ -32,16 +59,15 @@ 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,
+        "zarr_assets": zarr_assets,  # Separate zarr assets for easy access
+        "other_assets": other_assets,  # Non-zarr assets
         "stac_url": f"{STAC_API_URL}/collections/{STAC_COLLECTION}/items/{item.id}",
+        "asset_summary": {
+            "total_assets": len(assets),
+            "zarr_assets": len(zarr_assets),
+            "other_assets": len(other_assets),
+        }
     }
 
 
@@ -129,6 +155,10 @@ def search_imagery(
                 "datetime": datetime_str,
                 "max_cloud_cover": max_cloud_cover,
             },
+            "quality_info": {
+                "avg_cloud_cover": sum(item.properties.get("eo:cloud_cover", 100) for item in items) / len(items) if items else None,
+                "best_cloud_cover": min(item.properties.get("eo:cloud_cover", 100) for item in items) if items else None,
+            } if items else {},
         }
 
     except Exception as e:
@@ -176,7 +206,7 @@ def get_item_details(item_id: str) -> dict:
 
 def list_recent_imagery(
     location_name: Optional[str] = None,
-    days: int = 7,
+    days: int = 14,  # Changed from 7 to 14 days default
     max_cloud_cover: Optional[float] = None,
     max_items: Optional[int] = None,
 ) -> dict:
@@ -184,10 +214,11 @@ def list_recent_imagery(
     List recent Sentinel-2 imagery, optionally for a specific location.
 
     This is a convenience function that combines geocoding and search.
+    If no good quality results found, automatically extends search period.
 
     Args:
         location_name: Optional place name to search around
-        days: Number of days to look back (default: 7)
+        days: Number of days to look back (default: 14)
         max_cloud_cover: Maximum cloud cover percentage
         max_items: Maximum items to return
 
@@ -228,6 +259,25 @@ def list_recent_imagery(
         max_items=max_items,
     )
 
+    # If no results found and we used a restrictive cloud cover, try extending time and relaxing cloud cover
+    if result.get("success") and result.get("filtered_count", 0) == 0 and days < 30:
+        # Try 30 days with more permissive cloud cover
+        extended_start = end_date - timedelta(days=30)
+        relaxed_cloud = min((max_cloud_cover or DEFAULT_MAX_CLOUD_COVER) + 30, 80)
+        
+        extended_result = search_imagery(
+            bbox=bbox,
+            start_date=extended_start.strftime("%Y-%m-%d"),
+            end_date=end_date.strftime("%Y-%m-%d"),
+            max_cloud_cover=relaxed_cloud,
+            max_items=max_items,
+        )
+        
+        if extended_result.get("success") and extended_result.get("filtered_count", 0) > 0:
+            result = extended_result
+            result["extended_search"] = True
+            result["note"] = f"Extended search to 30 days with {relaxed_cloud}% cloud cover for better results"
+
     if location_info:
         result["location"] = location_info
 

{geomind_ai-1.1.0.dist-info → geomind_ai-1.2.0.dist-info}/METADATA

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

geomind_ai-1.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+geomind/__init__.py,sha256=LBwe1KUfm0hXjes2HDyeaN4LZb8tXlRnXqBUDRx3QoI,165
+geomind/agent.py,sha256=My9OikB0RnZulztSML_sPY3-0-dpVvGyfmbzD42Ppp0,8108
+geomind/cli.py,sha256=ipuMF0ZPseHHNKDD5VUMUG4fJDNmG_RQXNvAvT8Gbww,12085
+geomind/config.py,sha256=pgHir8A5tSLbIYz9zOMMwEXhGyECEA0JzStPjQOQfpM,2116
+geomind/tools/__init__.py,sha256=8iumGwIFHh8Bj1VJNgZtmKnEBqCy6_cRkzYENDUH7x4,720
+geomind/tools/geocoding.py,sha256=hiLpzHpkJP6IgWAUtZMnHL6qpkWcYWVLpGe0yfYxXv8,3007
+geomind/tools/processing.py,sha256=4sUrLGqxGqlVETMgHLxOeY-b1_kQ5bstKOjIHh2PbeU,12817
+geomind/tools/stac_search.py,sha256=a0OrxSe4bDNtD_cNHKBnQZHeCtx9B6S65HWxsCBaFxY,8854
+geomind_ai-1.2.0.dist-info/licenses/LICENSE,sha256=aveu0ERm7I3NnIu8rtpKdvd0eyRpmktXKU0PBABtSN0,1069
+geomind_ai-1.2.0.dist-info/METADATA,sha256=-gHApQirq64EklvWj8j7_B-SQjxcsXDCt_HjFe7dJpc,2405
+geomind_ai-1.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+geomind_ai-1.2.0.dist-info/entry_points.txt,sha256=2nPR3faYKl0-1epccvzMJ2xdi-Q1Vt7aOSvA84oIWnw,45
+geomind_ai-1.2.0.dist-info/top_level.txt,sha256=rjKWNSNRhq4R9xJoZGsG-eAaH7BmTVNvfrrbcaJMIIs,8
+geomind_ai-1.2.0.dist-info/RECORD,,

{geomind_ai-1.1.0.dist-info → geomind_ai-1.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

geomind_ai-1.1.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-geomind/__init__.py,sha256=MZ0Zr2vGCJ816ilSApbwhA6iEfCwEBk40etbvIGfpqs,165
-geomind/agent.py,sha256=2VDhPK9kvxf80KVoJLXbh8JGKbB8a3EiayojXd7ODOM,15661
-geomind/cli.py,sha256=hUONvWUW2QTVawMxpDtFonIAqbS-SiV-bMFthgqnr2g,5614
-geomind/config.py,sha256=7zPr0OKvK2SqQArUbjMvf5GVLQsmHcbn7e-BsSB1yv0,2030
-geomind/tools/__init__.py,sha256=8iumGwIFHh8Bj1VJNgZtmKnEBqCy6_cRkzYENDUH7x4,720
-geomind/tools/geocoding.py,sha256=hiLpzHpkJP6IgWAUtZMnHL6qpkWcYWVLpGe0yfYxXv8,3007
-geomind/tools/processing.py,sha256=mGu20uvpAVil2w2BEqj-0zYhKhCFuZHr1-3-vq0VzqM,10152
-geomind/tools/stac_search.py,sha256=V6230l4aHjedPWXu-3Cjmfc6diSFh5zsycewUko0W8k,6452
-geomind_ai-1.1.0.dist-info/licenses/LICENSE,sha256=aveu0ERm7I3NnIu8rtpKdvd0eyRpmktXKU0PBABtSN0,1069
-geomind_ai-1.1.0.dist-info/METADATA,sha256=EJROiPf8W_iht6qEaSyOzosyVob_hoodOe98ayFXAUE,2405
-geomind_ai-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-geomind_ai-1.1.0.dist-info/entry_points.txt,sha256=2nPR3faYKl0-1epccvzMJ2xdi-Q1Vt7aOSvA84oIWnw,45
-geomind_ai-1.1.0.dist-info/top_level.txt,sha256=rjKWNSNRhq4R9xJoZGsG-eAaH7BmTVNvfrrbcaJMIIs,8
-geomind_ai-1.1.0.dist-info/RECORD,,