npcpy 1.2.21__py3-none-any.whl → 1.2.23__py3-none-any.whl

npcpy/gen/response.py

@@ -475,9 +475,9 @@ def get_litellm_response(
                         pdf_data = load_pdf(attachment)
                         if pdf_data is not None:
                             if prompt:
-                                prompt += f"\n\nContent from PDF: {os.path.basename(attachment)}\n{pdf_data[:5000]}..."
+                                prompt += f"\n\nContent from PDF: {os.path.basename(attachment)}\n{pdf_data}..."
                             else:
-                                prompt = f"Content from PDF: {os.path.basename(attachment)}\n{pdf_data[:5000]}..."
+                                prompt = f"Content from PDF: {os.path.basename(attachment)}\n{pdf_data}..."
 
                     except Exception:
                         pass

npcpy/llm_funcs.py

@@ -1015,7 +1015,7 @@ def execute_multi_step_plan(
 
     step_outputs = []
     current_messages = messages.copy()
-    render_markdown(f"### Plan for Command: {command[100:]}")
+    render_markdown(f"### Plan for Command: {command[:100]}")
     for action in planned_actions:
         step_info = json.dumps({'action': action.get('action', ''), 
                                 'explanation': str(action.get('explanation',''))[0:10]+'...'})

npcpy/memory/command_history.py

@@ -619,6 +619,29 @@ class CommandHistory:
         }
         
         return self._execute_returning_id(stmt, params)
+    def get_memories_for_scope(
+        self,
+        npc: str,
+        team: str,
+        directory_path: str,
+        status: Optional[str] = None
+    ) -> List[Dict]:
+        
+        query = """
+            SELECT id, initial_memory, final_memory, 
+                status, timestamp, created_at
+            FROM memory_lifecycle
+            WHERE npc = :npc AND team = :team AND directory_path = :path
+        """
+        params = {"npc": npc, "team": team, "path": directory_path}
+        
+        if status:
+            query += " AND status = :status"
+            params["status"] = status
+        
+        query += " ORDER BY created_at DESC"
+        data =self._fetch_all(query, params)
+        return  data
 
     def search_memory(self, query: str, npc: str = None, team: str = None, 
                     directory_path: str = None, status_filter: str = None, limit: int = 10):

npcpy/memory/memory_processor.py

@@ -17,9 +17,7 @@ class MemoryItem:
     model: str
     provider: str
 
-
 def memory_approval_ui(memories: List[Dict]) -> List[Dict]:
-    """Simple CLI interface for memory approval"""
     if not memories:
         return []
     
@@ -29,37 +27,55 @@ def memory_approval_ui(memories: List[Dict]) -> List[Dict]:
     for i, memory in enumerate(memories, 1):
         print(f"\n--- Memory {i}/{len(memories)} ---")
         print(f"NPC: {memory['npc']}")
-        print(f"Content: {memory['content'][:200]}{'...' if len(memory['content']) > 200 else ''}")
+        content_preview = memory['content'][:200]
+        if len(memory['content']) > 200:
+            content_preview += '...'
+        print(f"Content: {content_preview}")
         
         while True:
-            choice = input("(a)pprove, (r)eject, (e)dit, (s)kip, (q)uit, (A)pprove all: ").strip().lower()
+            choice = input(
+                "(a)pprove, (r)eject, (e)dit, (s)kip | "
+                "(A)ll approve, (R)all reject, (S)all skip: "
+            ).strip().lower()
             
             if choice == 'a':
-                approvals.append({"memory_id": memory['memory_id'], "decision": "human-approved"})
+                approvals.append({
+                    "memory_id": memory['memory_id'],
+                    "decision": "human-approved"
+                })
                 break
             elif choice == 'r':
-                approvals.append({"memory_id": memory['memory_id'], "decision": "human-rejected"})
+                approvals.append({
+                    "memory_id": memory['memory_id'],
+                    "decision": "human-rejected"
+                })
                 break
             elif choice == 'e':
                 edited = input("Edit memory: ").strip()
                 if edited:
                     approvals.append({
-                        "memory_id": memory['memory_id'], 
+                        "memory_id": memory['memory_id'],
                         "decision": "human-edited",
                         "final_memory": edited
                     })
                 break
             elif choice == 's':
                 break
-            elif choice == 'q':
-                return approvals
             elif choice == 'A':
-                
                 for remaining_memory in memories[i-1:]:
                     approvals.append({
-                        "memory_id": remaining_memory['memory_id'], 
+                        "memory_id": remaining_memory['memory_id'],
                         "decision": "human-approved"
                     })
                 return approvals
+            elif choice == 'R':
+                for remaining_memory in memories[i-1:]:
+                    approvals.append({
+                        "memory_id": remaining_memory['memory_id'],
+                        "decision": "human-rejected"
+                    })
+                return approvals
+            elif choice == 'S':
+                return approvals
     
     return approvals

npcpy/sql/ai_function_tools.py

@@ -0,0 +1,257 @@
+import json
+from typing import Dict, Any, List, Optional
+
+class SQLToolCallResponse:
+    """
+    Represents a structured response with tool calling capabilities 
+    that can be generated and processed within SQL
+    """
+    @staticmethod
+    def generate_tool_call_prompt(
+        prompt: str, 
+        tools: List[Dict[str, Any]], 
+        model: str = 'snowflake-arctic'
+    ) -> str:
+        """
+        Generate a prompt that instructs the model to use tools
+        
+        :param prompt: Original user prompt
+        :param tools: List of available tools/functions
+        :param model: AI model to use
+        :return: Formatted prompt for tool-aware generation
+        """
+        tool_descriptions = [
+            f"Tool: {tool.get('name', 'unnamed')}\n"
+            f"Description: {tool.get('description', 'No description')}\n"
+            f"Parameters: {json.dumps(tool.get('parameters', {}))}"
+            for tool in tools
+        ]
+        
+        return f"""
+        You are an AI assistant capable of using the following tools:
+
+        {"\n\n".join(tool_descriptions)}
+
+        User Prompt: {prompt}
+
+        IMPORTANT INSTRUCTIONS:
+        1. Carefully analyze the user's request
+        2. Determine which tool(s) are most appropriate
+        3. Generate a structured JSON response with:
+           - tool_calls: List of tool invocations
+           - final_response: Your overall response to the user
+        4. ONLY use tools that are directly relevant
+        5. Format the output as a valid JSON object
+
+        Output Format:
+        {{
+            "tool_calls": [
+                {{
+                    "tool_name": "tool_name",
+                    "parameters": {{...}}
+                }}
+            ],
+            "final_response": "Optional explanation or summary"
+        }}
+        """
+
+    @staticmethod
+    def parse_tool_calls_sql(tool_call_json: str) -> Dict[str, Any]:
+        """
+        Parse tool calls within SQL, with error handling
+        
+        :param tool_call_json: JSON string of tool calls
+        :return: Parsed tool call dictionary
+        """
+        try:
+            parsed = json.loads(tool_call_json)
+            return {
+                'tool_calls': parsed.get('tool_calls', []),
+                'final_response': parsed.get('final_response', '')
+            }
+        except json.JSONDecodeError:
+            return {
+                'tool_calls': [],
+                'final_response': 'Error parsing tool calls'
+            }
+
+class SnowflakeSQLToolCaller:
+    """
+    Snowflake-specific tool calling implementation
+    """
+    @staticmethod
+    def generate_tool_call_sql(
+        prompt: str, 
+        tools: List[Dict[str, Any]], 
+        model: str = 'snowflake-arctic'
+    ) -> str:
+        """
+        Generate a SQL function that performs tool calling
+        
+        :param prompt: User prompt
+        :param tools: Available tools
+        :param model: AI model to use
+        :return: SQL function definition
+        """
+        tool_call_prompt = SQLToolCallResponse.generate_tool_call_prompt(
+            prompt, tools, model
+        )
+        
+        return f"""
+        WITH ai_response AS (
+            SELECT SNOWFLAKE.CORTEX.COMPLETE(
+                model => '{model}',
+                prompt => '{tool_call_prompt}'
+            ) AS response_json
+        ),
+        parsed_response AS (
+            SELECT 
+                response_json,
+                PARSE_JSON(response_json) AS parsed_json
+            FROM ai_response
+        ),
+        tool_calls AS (
+            SELECT 
+                elem.tool_name,
+                elem.parameters
+            FROM parsed_response,
+            LATERAL FLATTEN(input => parsed_json:tool_calls) elem
+        )
+        SELECT 
+            response_json,
+            tool_calls.tool_name,
+            tool_calls.parameters
+        FROM parsed_response
+        LEFT JOIN tool_calls ON 1=1
+        """
+
+class BigQuerySQLToolCaller:
+    """
+    BigQuery-specific tool calling implementation
+    """
+    @staticmethod
+    def generate_tool_call_sql(
+        prompt: str, 
+        tools: List[Dict[str, Any]], 
+        model: str = 'text-bison'
+    ) -> str:
+        """
+        Generate a BigQuery ML function for tool calling
+        
+        :param prompt: User prompt
+        :param tools: Available tools
+        :param model: AI model to use
+        :return: SQL function definition
+        """
+        tool_call_prompt = SQLToolCallResponse.generate_tool_call_prompt(
+            prompt, tools, model
+        )
+        
+        return f"""
+        ML.PREDICT(
+            MODEL `{model}`,
+            (
+                SELECT '{tool_call_prompt}' AS prompt
+            )
+        )
+        """
+
+class SQLToolCallOrchestrator:
+    """
+    Orchestrates tool calling across different SQL databases
+    """
+    @staticmethod
+    def generate_tool_calls(
+        engine_type: str,
+        prompt: str, 
+        tools: List[Dict[str, Any]], 
+        model: Optional[str] = None
+    ) -> str:
+        """
+        Generate appropriate SQL for tool calling
+        
+        :param engine_type: Type of SQL database
+        :param prompt: User prompt
+        :param tools: Available tools
+        :param model: Optional model override
+        :return: SQL for tool calling
+        """
+        model_map = {
+            'snowflake': 'snowflake-arctic',
+            'bigquery': 'text-bison'
+        }
+        
+        model = model or model_map.get(engine_type.lower(), 'snowflake-arctic')
+        
+        if engine_type.lower() == 'snowflake':
+            return SnowflakeSQLToolCaller.generate_tool_call_sql(
+                prompt, tools, model
+            )
+        elif engine_type.lower() == 'bigquery':
+            return BigQuerySQLToolCaller.generate_tool_call_sql(
+                prompt, tools, model
+            )
+        else:
+            raise ValueError(f"Unsupported engine type: {engine_type}")
+
+# Example integration with ModelCompiler
+def _execute_ai_agent_sql(
+    self, 
+    prompt: str, 
+    tools: List[Dict[str, Any]]
+) -> Dict[str, Any]:
+    """
+    Execute an AI agent entirely within SQL
+    
+    :param prompt: User prompt
+    :param tools: Available tools
+    :return: Tool call results
+    """
+    engine_type = self.engine.dialect.name.lower()
+    
+    try:
+        tool_call_sql = SQLToolCallOrchestrator.generate_tool_calls(
+            engine_type, prompt, tools
+        )
+        
+        # Execute the SQL and process results
+        df = pd.read_sql(tool_call_sql, self.engine)
+        
+        # Process tool calls and generate final response
+        tool_calls = self._process_sql_tool_calls(df)
+        
+        return {
+            'tool_calls': tool_calls,
+            'final_response': df['final_response'].iloc[0] if not df.empty else ''
+        }
+    
+    except Exception as e:
+        return {
+            'tool_calls': [],
+            'final_response': f"Error in SQL tool calling: {str(e)}"
+        }
+
+def _process_sql_tool_calls(self, df: pd.DataFrame) -> List[Dict[str, Any]]:
+    """
+    Process tool calls from SQL result DataFrame
+    
+    :param df: DataFrame containing tool call results
+    :return: List of processed tool calls
+    """
+    processed_calls = []
+    
+    for _, row in df.iterrows():
+        tool_name = row.get('tool_name')
+        parameters = row.get('parameters')
+        
+        if tool_name and parameters:
+            # Execute the tool using existing tool calling mechanism
+            tool_result = self._execute_tool(tool_name, parameters)
+            
+            processed_calls.append({
+                'tool_name': tool_name,
+                'parameters': parameters,
+                'result': tool_result
+            })
+    
+    return processed_calls

npcpy/sql/database_ai_adapters.py

@@ -0,0 +1,186 @@
+import sqlalchemy
+from typing import Dict, Any, Optional, Callable
+import textwrap
+
+class DatabaseAIAdapter:
+    """
+    Base class for database-specific AI function adapters
+    """
+    def __init__(self, engine: sqlalchemy.engine.base.Engine):
+        self.engine = engine
+        self.dialect = self._get_dialect()
+
+    def _get_dialect(self) -> str:
+        """Determine the specific database dialect"""
+        dialect_map = {
+            'postgresql': 'postgresql',
+            'mysql': 'mysql',
+            'mssql': 'mssql',
+            'sqlite': 'sqlite',
+            'snowflake': 'snowflake'
+        }
+        return dialect_map.get(self.engine.dialect.name.lower(), 'unknown')
+
+    def generate_ai_function(self, function_type: str, prompt: str, **kwargs) -> str:
+        """
+        Generate AI function implementation based on database type
+        
+        :param function_type: Type of AI function (generate_text, summarize, etc.)
+        :param prompt: Input prompt
+        :param kwargs: Additional parameters
+        :return: SQL implementation of AI function
+        """
+        adapter_method = getattr(self, f'_{self.dialect}_{function_type}', None)
+        
+        if adapter_method:
+            return adapter_method(prompt, **kwargs)
+        
+        # Fallback to generic implementation
+        return self._generic_ai_function(function_type, prompt, **kwargs)
+
+    def _generic_ai_function(self, function_type: str, prompt: str, **kwargs) -> str:
+        """
+        Generic fallback implementation using Python-based AI processing
+        """
+        # Create a temporary table-based approach for AI function simulation
+        return textwrap.dedent(f'''
+        WITH ai_input AS (
+            SELECT '{prompt}' AS input_text
+        )
+        SELECT 
+            CASE 
+                WHEN '{function_type}' = 'generate_text' THEN 
+                    'Generated text based on: ' || input_text
+                WHEN '{function_type}' = 'summarize' THEN 
+                    'Summary of: ' || input_text
+                WHEN '{function_type}' = 'analyze_sentiment' THEN 
+                    CASE 
+                        WHEN input_text LIKE '%good%' OR input_text LIKE '%great%' THEN 'positive'
+                        WHEN input_text LIKE '%bad%' OR input_text LIKE '%terrible%' THEN 'negative'
+                        ELSE 'neutral'
+                    END
+                ELSE input_text
+            END AS ai_result
+        FROM ai_input
+        ''')
+
+    def _postgresql_generate_text(self, prompt: str, **kwargs) -> str:
+        """
+        PostgreSQL-specific text generation using pgai extension
+        Requires: CREATE EXTENSION IF NOT EXISTS pgai;
+        """
+        return textwrap.dedent(f'''
+        SELECT pgai.generate_text(
+            model => 'openai-gpt-3.5-turbo', 
+            prompt => '{prompt}'
+        ) AS generated_text
+        ''')
+
+    def _mysql_generate_text(self, prompt: str, **kwargs) -> str:
+        """
+        MySQL-specific text generation 
+        Uses a custom table-based approach with external AI call simulation
+        """
+        return textwrap.dedent(f'''
+        WITH ai_input AS (
+            SELECT '{prompt}' AS input_text
+        )
+        SELECT 
+            CONCAT('Generated text based on: ', input_text) AS generated_text
+        FROM ai_input
+        ''')
+
+    def _mssql_generate_text(self, prompt: str, **kwargs) -> str:
+        """
+        MSSQL-specific text generation
+        Uses a CLR integration or external call simulation
+        """
+        return textwrap.dedent(f'''
+        WITH ai_input AS (
+            SELECT '{prompt}' AS input_text
+        )
+        SELECT 
+            CONCAT('Generated text based on: ', input_text) AS generated_text
+        FROM ai_input
+        ''')
+
+    def _postgresql_summarize(self, text: str, **kwargs) -> str:
+        """PostgreSQL summarization implementation"""
+        return textwrap.dedent(f'''
+        SELECT pgai.summarize(
+            text => '{text}',
+            max_length => 100
+        ) AS summary
+        ''')
+
+    def _postgresql_analyze_sentiment(self, text: str, **kwargs) -> str:
+        """PostgreSQL sentiment analysis implementation"""
+        return textwrap.dedent(f'''
+        SELECT 
+            CASE 
+                WHEN pgai.sentiment_score('{text}') > 0 THEN 'positive'
+                WHEN pgai.sentiment_score('{text}') < 0 THEN 'negative'
+                ELSE 'neutral'
+            END AS sentiment
+        ''')
+
+class AIFunctionRouter:
+    """
+    Routes AI function calls to appropriate database-specific adapters
+    """
+    @staticmethod
+    def route_ai_function(engine: sqlalchemy.engine.base.Engine, 
+                           function_type: str, 
+                           prompt: str, 
+                           **kwargs) -> str:
+        """
+        Route AI function to appropriate database adapter
+        
+        :param engine: SQLAlchemy database engine
+        :param function_type: Type of AI function
+        :param prompt: Input prompt
+        :param kwargs: Additional parameters
+        :return: SQL implementation of AI function
+        """
+        adapter = DatabaseAIAdapter(engine)
+        return adapter.generate_ai_function(function_type, prompt, **kwargs)
+
+# Example integration with existing ModelCompiler
+def _execute_ai_model(self, sql: str, model: SQLModel) -> pd.DataFrame:
+    """
+    Enhanced method to use AI function adapters
+    """
+    from npcpy.sql.database_ai_adapters import AIFunctionRouter
+    
+    # Existing code to determine source and engine
+    source_pattern = r'FROM\s+(\\w+)\\.(\\w+)'
+    matches = re.findall(source_pattern, sql)
+    
+    if matches:
+        source_name, table_name = matches[0]
+        engine = self._get_engine(source_name)
+        
+        # Modify SQL to use database-specific AI functions
+        for func_name, params in model.ai_functions.items():
+            try:
+                # Route AI function through adapter
+                native_func_call = AIFunctionRouter.route_ai_function(
+                    engine,
+                    func_name, 
+                    text=params.get('column', ''),
+                    **{k: v for k, v in params.items() if k != 'column'}
+                )
+                
+                # Replace the NQL function with native/adapted function
+                sql = sql.replace(
+                    f"nql.{func_name}({params.get('column', '')})", 
+                    native_func_call
+                )
+            except Exception as e:
+                # Fallback to original method if transformation fails
+                print(f"Warning: AI function adaptation failed: {e}. Falling back to default.")
+        
+        return pd.read_sql(sql.replace(f"{source_name}.", ""), engine)
+    
+    # Fallback to existing AI model execution
+    return super()._execute_ai_model(sql, model)