allowing Memory_Manager to search by tags with AND/OR operators

app.py

@@ -1077,19 +1077,129 @@ def _mem_list(
     return "\n".join(lines)
 
 
+def _parse_search_query(query: str) -> Dict[str, List[str]]:
+    """Parse a search query into structured components.
+    
+    Supports:
+        - tag:name - search for specific tag
+        - AND/OR operators (case-insensitive) 
+        - Regular text terms
+        - Implicit AND between terms when no operator specified
+    
+    Examples:
+        'tag:work' -> {'tag_terms': ['work'], 'text_terms': [], 'operator': 'and'}
+        'tag:work AND tag:project' -> {'tag_terms': ['work', 'project'], 'text_terms': [], 'operator': 'and'}
+        'tag:personal OR tag:todo' -> {'tag_terms': ['personal', 'todo'], 'text_terms': [], 'operator': 'or'}
+        'meeting tag:work' -> {'tag_terms': ['work'], 'text_terms': ['meeting'], 'operator': 'and'}
+        'tag:urgent OR important' -> {'tag_terms': ['urgent'], 'text_terms': ['important'], 'operator': 'or'}
+    
+    Returns:
+        Dict with keys: 'tag_terms', 'text_terms', 'operator' (and/or)
+    """
+    import re
+    
+    # Initialize result
+    result = {
+        'tag_terms': [],
+        'text_terms': [],
+        'operator': 'and'  # default
+    }
+    
+    if not query or not query.strip():
+        return result
+    
+    # Normalize whitespace and detect OR operator
+    query = re.sub(r'\s+', ' ', query.strip())
+    if re.search(r'\bOR\b', query, re.IGNORECASE):
+        result['operator'] = 'or'
+        # Split on OR (case-insensitive)
+        parts = re.split(r'\s+OR\s+', query, flags=re.IGNORECASE)
+    else:
+        # Split on AND (case-insensitive) or just whitespace
+        parts = re.split(r'\s+(?:AND\s+)?', query, flags=re.IGNORECASE)
+        # Remove empty AND tokens that might have been left
+        parts = [p for p in parts if p.strip() and p.strip().upper() != 'AND']
+    
+    # Process each part
+    for part in parts:
+        part = part.strip()
+        if not part:
+            continue
+            
+        # Check if it's a tag query
+        tag_match = re.match(r'^tag:(.+)$', part, re.IGNORECASE)
+        if tag_match:
+            tag_name = tag_match.group(1).strip()
+            if tag_name:
+                result['tag_terms'].append(tag_name.lower())
+        else:
+            # Regular text term
+            result['text_terms'].append(part.lower())
+    
+    return result
+
+
+def _match_memory_with_query(memory: Dict[str, str], parsed_query: Dict[str, List[str]]) -> bool:
+    """Check if a memory matches the parsed search query."""
+    tag_terms = parsed_query['tag_terms']
+    text_terms = parsed_query['text_terms']
+    operator = parsed_query['operator']
+    
+    # If no terms, no match
+    if not tag_terms and not text_terms:
+        return False
+    
+    # Get memory content (case-insensitive)
+    memory_text = memory.get('text', '').lower()
+    memory_tags = memory.get('tags', '').lower()
+    
+    # Split memory tags into individual tags
+    memory_tag_list = [tag.strip() for tag in memory_tags.split(',') if tag.strip()]
+    
+    # Check tag matches
+    tag_matches = []
+    for tag_term in tag_terms:
+        # Check if tag_term matches any of the memory's tags
+        tag_matches.append(any(tag_term in tag for tag in memory_tag_list))
+    
+    # Check text matches
+    text_matches = []
+    combined_text = memory_text + ' ' + memory_tags  # For backward compatibility
+    for text_term in text_terms:
+        text_matches.append(text_term in combined_text)
+    
+    # Combine all matches
+    all_matches = tag_matches + text_matches
+    
+    if not all_matches:
+        return False
+    
+    # Apply operator logic
+    if operator == 'or':
+        return any(all_matches)
+    else:  # 'and'
+        return all(all_matches)
+
+
 def _mem_search(
-    query: Annotated[str, "Case-insensitive substring search; space-separated terms are ANDed."],
+    query: Annotated[str, "Advanced search with tag:name syntax, AND/OR operators, and text terms."],
     limit: Annotated[int, "Maximum number of matches (1–200)."] = 20,
 ) -> str:
-    """(Internal) Full-text style AND search across text and tags.
-
-    Search Semantics:
-        - Split query on whitespace into individual terms.
-        - A memory matches only if EVERY term appears (case-insensitive) in the text OR tags field.
-        - Results are ordered newest-first (descending timestamp).
+    """(Internal) Enhanced search with tag queries and boolean operators.
+
+    Search Syntax:
+        - tag:name - search for specific tag
+        - AND/OR operators (case-insensitive, default is AND)
+        - Regular text terms search in text content and tags
+        - Examples:
+          * 'tag:work' - memories with 'work' tag
+          * 'tag:work AND tag:project' - memories with both tags  
+          * 'tag:personal OR tag:todo' - memories with either tag
+          * 'meeting tag:work' - memories with "meeting" in text and 'work' tag
+          * 'tag:urgent OR important' - memories with 'urgent' tag OR "important" anywhere
 
     Parameters:
-        query (str): Raw user query string; must contain at least one non-space character.
+        query (str): Enhanced query string with tag: syntax and AND/OR operators.
         limit (int): Max rows to return; clamped to [1, 200].
 
     Returns:
@@ -1098,18 +1208,21 @@ def _mem_search(
     q = (query or "").strip()
     if not q:
         return "Error: empty query."
-    terms = [t.lower() for t in q.split() if t.strip()]
-    if not terms:
-        return "Error: no valid search terms."
+    
+    # Parse the enhanced query
+    parsed_query = _parse_search_query(q)
+    if not parsed_query['tag_terms'] and not parsed_query['text_terms']:
+        return "Error: no valid search terms found."
+    
     limit = max(1, min(200, limit))
     with _MEMORY_LOCK:
         memories = _load_memories()
-    # Newest first iteration for early cutoff
-    matches: List[Dict[str, str]] = []  # collected (capped at limit)
+    
+    # Search with enhanced logic
+    matches: List[Dict[str, str]] = []
     total_matches = 0
-    for m in reversed(memories):  # newest backward
-        hay = (m.get("text", "") + " " + m.get("tags", "")).lower()
-        if all(t in hay for t in terms):
+    for m in reversed(memories):  # newest first
+        if _match_memory_with_query(m, parsed_query):
             total_matches += 1
             if len(matches) < limit:
                 matches.append(m)
@@ -1479,7 +1592,7 @@ def Memory_Manager(
     action: Annotated[Literal["save","list","search","delete"], "Action to perform: save | list | search | delete"],
     text: Annotated[Optional[str], "Text content (Save only)"] = None,
     tags: Annotated[Optional[str], "Comma-separated tags (Save only)"] = None,
-    query: Annotated[Optional[str], "Search query terms (Search only)"] = None,
+    query: Annotated[Optional[str], "Enhanced search with tag:name syntax, AND/OR operators (Search only)"] = None,
     limit: Annotated[int, "Max results (List/Search only)"] = 20,
     memory_id: Annotated[Optional[str], "Full UUID or unique prefix (Delete only)"] = None,
     include_tags: Annotated[bool, "Include tags (List/Search only)"] = True,
@@ -1494,7 +1607,7 @@ def Memory_Manager(
     Supported Actions:
         - save   : Store a new memory (requires 'text'; optional 'tags').
         - list   : Return the most recent memories (respects 'limit' + 'include_tags').
-        - search : AND match space‑separated terms across text and tags (uses 'query', 'limit').
+        - search : Enhanced AND match with tag: queries, boolean operators, and text terms (uses 'query', 'limit').
         - delete : Remove one memory by full UUID or unique prefix (uses 'memory_id').
 
     Parameter Usage by Action:
@@ -1507,7 +1620,11 @@ def Memory_Manager(
         action (Literal[save|list|search|delete]): Operation selector (case-insensitive).
         text (str): Raw memory content; leading/trailing whitespace trimmed (save only).
         tags (str): Optional comma-separated tags; stored verbatim (save only).
-        query (str): Space-separated terms (AND logic, case-insensitive) across text+tags (search only).
+        query (str): Enhanced search query supporting:
+            - tag:name - search for specific tag
+            - AND/OR operators (case-insensitive, default is AND)  
+            - Regular text terms search in text content and tags
+            - Examples: 'tag:work', 'tag:work AND tag:project', 'meeting tag:work', 'tag:urgent OR important'
         limit (int): Maximum rows for list/search (clamped internally to 1–200).
         memory_id (str): Full UUID or unique prefix (>=4 chars) (delete only).
         include_tags (bool): When True, show tag column in list/search output.
@@ -1561,7 +1678,7 @@ memory_interface = gr.Interface(
         gr.Dropdown(label="Action", choices=["save","list","search","delete"], value="list"),
         gr.Textbox(label="Text", lines=3, placeholder="Memory text (save)"),
         gr.Textbox(label="Tags", placeholder="tag1, tag2"),
-        gr.Textbox(label="Query", placeholder="Search terms (search)"),
+        gr.Textbox(label="Query", placeholder="tag:work AND tag:project OR meeting"),
         gr.Slider(1, 200, value=20, step=1, label="Limit"),
         gr.Textbox(label="Memory ID / Prefix", placeholder="UUID or prefix (delete)"),
         gr.Checkbox(value=True, label="Include Tags"),
@@ -1573,8 +1690,10 @@ memory_interface = gr.Interface(
     ),
     api_description=(
         "Manage short text memories with optional tags. Actions: save(text,tags), list(limit,include_tags), "
-        "search(query,limit,include_tags), delete(memory_id). Returns plaintext JSON. Action parameter is always required. "
-        "Use Memory_Manager whenever you are given information worth remembering about the user, and search for memories when relevant."
+        "search(query,limit,include_tags), delete(memory_id). Enhanced search supports tag:name queries and AND/OR operators. "
+        "Examples: 'tag:work', 'tag:work AND tag:project', 'meeting tag:work', 'tag:urgent OR important'. "
+        "Action parameter is always required. Use Memory_Manager whenever you are given information worth remembering about the user, "
+        "and search for memories when relevant."
     ),
     flagging_mode="never",
 )