scopemate 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

scopemate/__init__.py

@@ -4,7 +4,7 @@ This package provides tools for breaking down complex tasks using
 the Purpose/Scope/Outcome planning approach.
 """
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"
 
 # Public API
 from .models import (

scopemate/llm.py

@@ -6,8 +6,14 @@ This module provides functions for interacting with LLMs for task estimation,
 breakdown, and optimization.
 """
 import json
+import os
 from typing import Dict, Any, List, Optional
+from enum import Enum, auto
+
+# Import LLM providers
 from openai import OpenAI
+import google.generativeai as genai
+from anthropic import Anthropic
 
 from .models import (
     ScopeMateTask, Scope, TIME_COMPLEXITY, SIZE_COMPLEXITY,
@@ -17,25 +23,68 @@ from .models import (
 # -------------------------------
 # Configuration
 # -------------------------------
-DEFAULT_MODEL = "o4-mini"
+class LLMProvider(Enum):
+    """Supported LLM providers"""
+    OPENAI = auto()
+    GEMINI = auto()
+    CLAUDE = auto()
+
+# Default configuration
+DEFAULT_PROVIDER = LLMProvider.OPENAI
+DEFAULT_OPENAI_MODEL = "o4-mini"
+DEFAULT_GEMINI_MODEL = "gemini-2.0-flash"
+DEFAULT_CLAUDE_MODEL = "claude-3-7-sonnet-20250219"
+
+# Provider-specific model mapping
+DEFAULT_MODELS = {
+    LLMProvider.OPENAI: DEFAULT_OPENAI_MODEL,
+    LLMProvider.GEMINI: DEFAULT_GEMINI_MODEL,
+    LLMProvider.CLAUDE: DEFAULT_CLAUDE_MODEL
+}
+
+# Get provider from environment variable or use default
+def get_llm_provider() -> LLMProvider:
+    """Get the LLM provider from environment variable or use default"""
+    provider_str = os.environ.get("SCOPEMATE_LLM_PROVIDER", "").upper()
+    if provider_str == "OPENAI":
+        return LLMProvider.OPENAI
+    elif provider_str == "GEMINI":
+        return LLMProvider.GEMINI
+    elif provider_str == "CLAUDE": 
+        return LLMProvider.CLAUDE
+    return DEFAULT_PROVIDER
+
+# Get model for the provider from environment variable or use default
+def get_llm_model(provider: LLMProvider = None) -> str:
+    """Get the LLM model for the provider from environment variable or use default"""
+    if provider is None:
+        provider = get_llm_provider()
+    
+    if provider == LLMProvider.OPENAI:
+        return os.environ.get("SCOPEMATE_OPENAI_MODEL", DEFAULT_OPENAI_MODEL)
+    elif provider == LLMProvider.GEMINI:
+        return os.environ.get("SCOPEMATE_GEMINI_MODEL", DEFAULT_GEMINI_MODEL)
+    elif provider == LLMProvider.CLAUDE:
+        return os.environ.get("SCOPEMATE_CLAUDE_MODEL", DEFAULT_CLAUDE_MODEL)
+    
+    return DEFAULT_MODELS[DEFAULT_PROVIDER]
 
 # -------------------------------
 # LLM Interaction
 # -------------------------------
-def call_llm(prompt: str, model: str = DEFAULT_MODEL) -> dict:
+def call_llm(prompt: str, system_prompt: str = None, model: str = None, provider: LLMProvider = None) -> dict:
     """
     Invoke LLM to get a structured JSON response.
     
     This function is the core LLM integration point for scopemate, handling all
-    communication with the OpenAI API. It's designed to always return structured
+    communication with the supported LLM APIs. It's designed to always return structured
     JSON data that can be easily processed by the application.
     
     The function:
-    1. Creates an OpenAI client using the default API credentials
+    1. Creates a client for the selected provider (OpenAI, Gemini, or Claude)
     2. Configures a system prompt that instructs the model to return valid JSON
     3. Sends the user's prompt with the task-specific instructions
-    4. Sets response_format to force JSON output
-    5. Parses and returns the JSON response
+    4. Parses and returns the JSON response
     
     Error handling is built in to gracefully handle JSON parsing failures by
     printing diagnostic information and returning an empty dictionary rather
@@ -44,50 +93,188 @@ def call_llm(prompt: str, model: str = DEFAULT_MODEL) -> dict:
     Args:
         prompt (str): The prompt to send to the LLM, containing full instructions
                       and any task data needed for context
-        model (str): The OpenAI model identifier to use (defaults to DEFAULT_MODEL)
+        model (str, optional): The model identifier to use (defaults to provider's default model)
+        provider (LLMProvider, optional): The LLM provider to use (defaults to configured provider)
         
     Returns:
         dict: A dictionary containing the parsed JSON response from the LLM.
               Returns an empty dict {} if parsing fails.
-              
-    Example:
-        ```python
-        # Create a prompt asking for task breakdown
-        prompt = f"Break down this task into subtasks: {task.title}"
-        
-        # Call the LLM and get structured data back
-        response = call_llm(prompt)
-        
-        # Process the structured response
-        if "subtasks" in response:
-            for subtask_data in response["subtasks"]:
-                # Create a new subtask from the data
-                subtask = ScopeMateTask(**subtask_data)
-                tasks.append(subtask)
-        ```
     """
-    client = OpenAI()
-    response = client.chat.completions.create(
-        model=model,
-        messages=[
-            {
-                "role": "system", 
-                "content": "You are a JSON assistant specialized in structured data for product management tasks. "
-                           "Respond only with valid JSON. Follow the exact requested format in the user's prompt, "
-                           "using the exact field names and adhering to all constraints on field values."
-            },
-            {"role": "user", "content": prompt}
-        ],
-        response_format={"type": "json_object"}
-    )
+    # Determine which provider to use
+    if provider is None:
+        provider = get_llm_provider()
+    
+    # Determine which model to use
+    if model is None:
+        model = get_llm_model(provider)
+    
+    # System prompt is common across providers
+    if system_prompt is None:
+        system_prompt = (
+            "You are a JSON assistant specialized in structured data for product management tasks. "
+            "Respond only with valid JSON. Follow the exact requested format in the user's prompt, "
+            "using the exact field names and adhering to all constraints on field values."
+        )
+    
+    # Call the appropriate provider with JSON response format
+    response_text = _call_provider(prompt, system_prompt, model, provider, response_format="json")
     
+    # Parse JSON response
     try:
-        return json.loads(response.choices[0].message.content)
+        if response_text:
+            return json.loads(response_text)
+        return {}
     except json.JSONDecodeError as e:
         print(f"[Error] Failed to parse LLM response as JSON: {e}")
-        print(f"Raw response: {response.choices[0].message.content}")
+        print(f"Raw response: {response_text}")
         return {}
 
+def call_llm_text(prompt: str, system_prompt: str = None, model: str = None, provider: LLMProvider = None) -> str:
+    """
+    Invoke LLM to get a plain text response (not JSON).
+    
+    This is similar to call_llm but returns plain text instead of JSON.
+    
+    Args:
+        prompt (str): The prompt to send to the LLM
+        system_prompt (str, optional): The system prompt to use
+        model (str, optional): The model identifier to use (defaults to provider's default model)
+        provider (LLMProvider, optional): The LLM provider to use (defaults to configured provider)
+        
+    Returns:
+        str: The text response from the LLM, or empty string on error
+    """
+    # Determine which provider to use
+    if provider is None:
+        provider = get_llm_provider()
+    
+    # Determine which model to use
+    if model is None:
+        model = get_llm_model(provider)
+    
+    # System prompt is common across providers
+    if system_prompt is None:
+        system_prompt = (
+            "You are a helpful assistant that provides clear and concise answers. "
+            "Respond directly to the question without adding additional explanation or context."
+        )
+    
+    print(f"Calling LLM (text mode) with provider: {provider}, model: {model}")
+    
+    # Call the appropriate provider with text response format
+    return _call_provider(prompt, system_prompt, model, provider, response_format="text")
+
+def _call_provider(prompt: str, system_prompt: str, model: str, provider: LLMProvider, response_format: str = "json") -> str:
+    """
+    Internal helper function to call the appropriate LLM provider.
+    
+    Args:
+        prompt (str): The prompt to send to the LLM
+        system_prompt (str): The system prompt to use
+        model (str): The model to use
+        provider (LLMProvider): The provider to use
+        response_format (str): Either "json" or "text"
+        
+    Returns:
+        str: The raw text response from the LLM
+    """
+    try:
+        if provider == LLMProvider.OPENAI:
+            return _call_openai_provider(prompt, system_prompt, model, response_format)
+        elif provider == LLMProvider.GEMINI:
+            return _call_gemini_provider(prompt, system_prompt, model, response_format)
+        elif provider == LLMProvider.CLAUDE:
+            return _call_claude_provider(prompt, system_prompt, model, response_format)
+        
+        # Fallback to OpenAI if unknown provider
+        print(f"[Warning] Unknown provider {provider}, falling back to OpenAI")
+        return _call_openai_provider(prompt, system_prompt, DEFAULT_OPENAI_MODEL, response_format)
+    except Exception as e:
+        print(f"[Error] LLM API call failed: {e}")
+        return ""
+
+def _call_openai_provider(prompt: str, system_prompt: str, model: str, response_format: str) -> str:
+    """Internal helper function to call OpenAI API"""
+    try:
+        client = OpenAI()
+        
+        # Configure response format for JSON if requested
+        kwargs = {}
+        if response_format == "json":
+            kwargs["response_format"] = {"type": "json_object"}
+        
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt}
+            ],
+            **kwargs
+        )
+        
+        # Return raw content text
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"[Error] OpenAI API call failed: {e}")
+        return ""
+
+def _call_gemini_provider(prompt: str, system_prompt: str, model: str, response_format: str) -> str:
+    """Internal helper function to call Gemini API"""
+    try:
+        # Check for API key in environment
+        api_key = os.environ.get("GEMINI_API_KEY", None)
+        if not api_key:
+            print("[Error] No API key found for Gemini. Set GEMINI_API_KEY environment variable.")
+            return ""
+        # Initialize the Gemini client
+        genai.configure(api_key=api_key)
+        
+        # Since system role is not supported, combine system prompt and user prompt
+        combined_prompt = f"{system_prompt}\n\n{prompt}"
+        
+        # Configure response format for JSON if requested
+        generation_config = {}
+        if response_format == "json":
+            generation_config["response_mime_type"] = "application/json"
+        
+        # Generate response using Gemini
+        model_name = model if model != system_prompt else DEFAULT_GEMINI_MODEL
+        model_obj = genai.GenerativeModel(model_name=model_name, generation_config=generation_config)
+        response = model_obj.generate_content(combined_prompt)
+        
+        text = response.text.strip()
+        
+        # Remove quotes if present for text responses
+        if response_format == "text" and text.startswith('"') and text.endswith('"'):
+            text = text[1:-1]
+            
+        return text
+    except Exception as e:
+        print(f"[Error] Gemini API call failed: {e}")
+        return ""
+
+def _call_claude_provider(prompt: str, system_prompt: str, model: str, response_format: str) -> str:
+    """Internal helper function to call Claude API"""
+    try:
+        client = Anthropic()
+        
+        # Configure temperature - lower for JSON for more deterministic output
+        temperature = 0.1 if response_format == "json" else 0.2
+        
+        response = client.messages.create(
+            model=model,
+            system=system_prompt,
+            max_tokens=4096,
+            messages=[
+                {"role": "user", "content": prompt}
+            ],
+            temperature=temperature
+        )
+        
+        return response.content[0].text.strip()
+    except Exception as e:
+        print(f"[Error] Claude API call failed: {e}")
+        return ""
 
 def estimate_scope(task: ScopeMateTask) -> Scope:
     """
@@ -340,35 +527,34 @@ def update_parent_with_child_context(parent_task: ScopeMateTask, child_task: Sco
     return updated_parent
 
 
-def generate_title_from_purpose_outcome(purpose: str, outcome: str) -> str:
+def generate_title_from_purpose_outcome(purpose: str, outcome: str, model: str = None, provider: LLMProvider = None) -> str:
     """
     Use LLM to generate a concise title from purpose and outcome descriptions.
     
     Args:
         purpose: The purpose description
         outcome: The outcome description
+        model (str, optional): The model identifier to use (defaults to provider's default model)
+        provider (LLMProvider, optional): The LLM provider to use (defaults to configured provider)
         
     Returns:
         A concise title string
     """
-    client = OpenAI()
-    response = client.chat.completions.create(
-        model=DEFAULT_MODEL,
-        messages=[
-            {
-                "role": "system", 
-                "content": "You are a concise title generator. Generate a brief, clear title (maximum 60 characters) "
-                          "that captures the essence of a task based on its purpose and outcome description."
-            },
-            {
-                "role": "user", 
-                "content": f"Purpose: {purpose}\n\nOutcome: {outcome}\n\nGenerate a concise title (max 60 chars):"
-            }
-        ]
+    system_prompt = (
+        "You are a concise title generator. Generate a brief, clear title (maximum 60 characters) "
+        "that captures the essence of a task based on its purpose and outcome description. "
+        "Return ONLY the title with no additional text or quotes."
     )
     
-    # Extract title from LLM response
-    title = response.choices[0].message.content.strip()
+    user_prompt = f"Purpose: {purpose}\n\nOutcome: {outcome}\n\nGenerate a concise title (max 60 chars):"
+    
+    # Use the common text-based LLM function
+    title = call_llm_text(user_prompt, system_prompt, model, provider)
+    
+    # Handle empty response
+    if not title:
+        return "Task Title"
+    
     # Limit title length if needed
     if len(title) > 60:
         title = title[:57] + "..."

{scopemate-0.1.2.dist-info → scopemate-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scopemate
-Version: 0.1.2
+Version: 0.2.0
 Summary: 🪜 A CLI tool for Purpose/Scope/Outcome planning
 Author: Anoop Thomas Mathew
 Author-email: Anoop Thomas Mathew <atmb4u@gmail.com>
@@ -24,6 +24,10 @@ License-File: LICENSE
 Requires-Dist: openai>=1.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: twine>=6.1.0
+Requires-Dist: google-generativeai>=0.3.0
+Requires-Dist: anthropic>=0.12.0
+Requires-Dist: ipython>=8.35.0
+Requires-Dist: ipdb>=0.13.13
 Dynamic: author
 Dynamic: license-file
 Dynamic: requires-python
@@ -83,7 +87,10 @@ Scopemate is built around a three-part framework for strategic decision making:
 ## Requirements
 
 - Python 3.10 or higher
-- OpenAI API key set as environment variable (`OPENAI_API_KEY`)
+- An API key for one of the supported LLM providers:
+  - OpenAI API key (default)
+  - Google AI (Gemini) API key
+  - Anthropic (Claude) API key
 
 ## Installation
 
@@ -134,26 +141,123 @@ cd scopemate
 pip install -e .
 ```
 
-### Setting up the OpenAI API Key
+### Setting up API Keys
 
-scopemate requires an OpenAI API key to function. Set it as an environment variable:
+scopemate now supports multiple LLM providers. Set up the API key for your preferred provider:
 
-#### macOS/Linux
+#### OpenAI (Default)
+
+Set the OpenAI API key as an environment variable:
+
+##### macOS/Linux
 ```bash
 export OPENAI_API_KEY=your-api-key-here
 ```
 
-#### Windows Command Prompt
+##### Windows Command Prompt
 ```cmd
 set OPENAI_API_KEY=your-api-key-here
 ```
 
-#### Windows PowerShell
+##### Windows PowerShell
 ```powershell
 $env:OPENAI_API_KEY = "your-api-key-here"
 ```
 
-For permanent setup, add this to your shell profile or environment variables.
+#### Google AI (Gemini)
+
+Set the Google AI API key as an environment variable:
+
+##### macOS/Linux
+```bash
+export GEMINI_API_KEY=your-api-key-here
+```
+
+##### Windows Command Prompt
+```cmd
+set GEMINI_API_KEY=your-api-key-here
+```
+
+##### Windows PowerShell
+```powershell
+$env:GEMINI_API_KEY = "your-api-key-here"
+```
+
+#### Anthropic (Claude)
+
+Set the Anthropic API key as an environment variable:
+
+##### macOS/Linux
+```bash
+export ANTHROPIC_API_KEY=your-api-key-here
+```
+
+##### Windows Command Prompt
+```cmd
+set ANTHROPIC_API_KEY=your-api-key-here
+```
+
+##### Windows PowerShell
+```powershell
+$env:ANTHROPIC_API_KEY = "your-api-key-here"
+```
+
+### Selecting LLM Provider
+
+You can select which LLM provider to use by setting the `SCOPEMATE_LLM_PROVIDER` environment variable:
+
+#### macOS/Linux
+```bash
+# Use OpenAI (default)
+export SCOPEMATE_LLM_PROVIDER=OPENAI
+
+# Use Gemini
+export SCOPEMATE_LLM_PROVIDER=GEMINI
+
+# Use Claude
+export SCOPEMATE_LLM_PROVIDER=CLAUDE
+```
+
+#### Windows Command Prompt
+```cmd
+# Use OpenAI (default)
+set SCOPEMATE_LLM_PROVIDER=OPENAI
+
+# Use Gemini
+set SCOPEMATE_LLM_PROVIDER=GEMINI
+
+# Use Claude
+set SCOPEMATE_LLM_PROVIDER=CLAUDE
+```
+
+#### Windows PowerShell
+```powershell
+# Use OpenAI (default)
+$env:SCOPEMATE_LLM_PROVIDER = "OPENAI"
+
+# Use Gemini
+$env:SCOPEMATE_LLM_PROVIDER = "GEMINI"
+
+# Use Claude
+$env:SCOPEMATE_LLM_PROVIDER = "CLAUDE"
+```
+
+### Selecting Model
+
+You can also specify which model to use for each provider:
+
+```bash
+# OpenAI model (default is o4-mini)
+export SCOPEMATE_OPENAI_MODEL=gpt-4-turbo
+
+# Gemini model (default is gemini-flash)
+export SCOPEMATE_GEMINI_MODEL=gemini-2.0-flash
+
+# Claude model (default is claude-3-haiku-20240307)
+export SCOPEMATE_CLAUDE_MODEL=claude-3-7-sonnet-20250219
+```
+
+For permanent setup, add these environment variables to your shell profile or system environment variables.
 
 ## Usage
 

{scopemate-0.1.2.dist-info → scopemate-0.2.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
-scopemate/__init__.py,sha256=sMbeuIqGXqrO47d1LD4gk6r5cLHuZmRtVXR797c8K2s,472
+scopemate/__init__.py,sha256=xp32RvKQnWl1JCBMwuDsSDYg8awCryN2iBWSpJVB2es,472
 scopemate/__main__.py,sha256=nPNZe_QEoOHQ_hXf17w72BHz1UFPKuW2g3whTLwuM8E,195
 scopemate/breakdown.py,sha256=mwIDzf7m2GHVkDrRmMyeS8v2pNd99U3vlcPCtOajvs0,21048
 scopemate/cli.py,sha256=qh6iFleQc8Bld0iptyUgRm5Ga3GtZsvE6Y-q6vbm3dk,6891
 scopemate/core.py,sha256=wpXCpb5Kdpqul9edNCx2Da94137XCc1w-3KQc9-Tf3s,700
 scopemate/engine.py,sha256=8yQoxSECJCGuNSIwS-qFoaOGM1iaZ-y4Lo7k5Q6v-mk,16992
 scopemate/interaction.py,sha256=SeqQVME0MATK-m-M7T9nNHkcJ_VCRhlqydL_vQaSMWk,10893
-scopemate/llm.py,sha256=k_1FQdg_TRt_51Yu_g_PjO0pBnmFmWHoK_-KEPGlASM,15526
+scopemate/llm.py,sha256=DLa2cL4pTYjnUG__gS_Lfifx3Mnpfm2QACpJSO9ooJo,23038
 scopemate/models.py,sha256=Q3SUoHu_4RejDAocEr83I00wGvxhDoJ1COVqjPsr4DQ,7738
 scopemate/storage.py,sha256=uV1-7IdwJwBENeNoO9Y3WwUUXd-jA2NvKdiERGGhmV8,11642
 scopemate/task_analysis.py,sha256=Mic0FOOy_BWI1_5TQmh__39miOcZBZ7mTUcCkv1DvkI,14967
-scopemate-0.1.2.dist-info/licenses/LICENSE,sha256=4fqQFK5AkkXmg6FBG9Wr06gCR7BMQl02TvsPYt-YL6s,1076
-scopemate-0.1.2.dist-info/METADATA,sha256=APn2Igy4cl3jhcP9gh6gwOHnBLMnN3CPsL4MrvDVabc,11774
-scopemate-0.1.2.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-scopemate-0.1.2.dist-info/entry_points.txt,sha256=XXusGEDxI6NlrYmSBcPDtjV3QvsHWVWPSrt4zD4UcLg,49
-scopemate-0.1.2.dist-info/top_level.txt,sha256=riMrI_jMCfZMb7-ecWBwqOBLdUsnPOxSu2Pgvqx7Too,10
-scopemate-0.1.2.dist-info/RECORD,,
+scopemate-0.2.0.dist-info/licenses/LICENSE,sha256=4fqQFK5AkkXmg6FBG9Wr06gCR7BMQl02TvsPYt-YL6s,1076
+scopemate-0.2.0.dist-info/METADATA,sha256=35WLUUsU01syRayWxXrx5Lt-bOqHwY31FBplRN9wCJ8,13835
+scopemate-0.2.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+scopemate-0.2.0.dist-info/entry_points.txt,sha256=XXusGEDxI6NlrYmSBcPDtjV3QvsHWVWPSrt4zD4UcLg,49
+scopemate-0.2.0.dist-info/top_level.txt,sha256=riMrI_jMCfZMb7-ecWBwqOBLdUsnPOxSu2Pgvqx7Too,10
+scopemate-0.2.0.dist-info/RECORD,,

{scopemate-0.1.2.dist-info → scopemate-0.2.0.dist-info}/WHEEL

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