omni-cortex 1.17.1__py3-none-any.whl → 1.17.3__py3-none-any.whl

omni_cortex/_bundled/hooks/subagent_stop.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""SubagentStop hook - logs when a subagent completes.
+
+This hook is called when a subagent (spawned by the Task tool) finishes.
+It logs the subagent completion and any results.
+
+Hook configuration for settings.json:
+{
+    "hooks": {
+        "SubagentStop": [
+            {
+                "type": "command",
+                "command": "python hooks/subagent_stop.py"
+            }
+        ]
+    }
+}
+"""
+
+import json
+import sys
+import os
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def get_db_path() -> Path:
+    """Get the database path for the current project."""
+    project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+    return Path(project_path) / ".omni-cortex" / "cortex.db"
+
+
+def generate_id() -> str:
+    """Generate a unique activity ID."""
+    timestamp_ms = int(datetime.now().timestamp() * 1000)
+    random_hex = os.urandom(4).hex()
+    return f"act_{timestamp_ms}_{random_hex}"
+
+
+def truncate(text: str, max_length: int = 10000) -> str:
+    """Truncate text to max length."""
+    if len(text) <= max_length:
+        return text
+    return text[:max_length - 20] + "\n... [truncated]"
+
+
+def main():
+    """Process SubagentStop hook."""
+    try:
+        # Read input from stdin
+        input_data = json.load(sys.stdin)
+
+        db_path = get_db_path()
+
+        # Only log if database exists
+        if not db_path.exists():
+            print(json.dumps({}))
+            return
+
+        # Extract data from hook input
+        subagent_id = input_data.get("subagent_id")
+        subagent_type = input_data.get("subagent_type", "subagent")
+        result = input_data.get("result", {})
+
+        session_id = os.environ.get("CLAUDE_SESSION_ID")
+        project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+        now = datetime.now(timezone.utc).isoformat()
+
+        # Connect to database
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+
+        # Log the subagent completion as an activity
+        cursor.execute(
+            """
+            INSERT INTO activities (
+                id, session_id, agent_id, timestamp, event_type,
+                tool_name, tool_output, success, project_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                generate_id(),
+                session_id,
+                subagent_id,
+                now,
+                "subagent_stop",
+                f"subagent_{subagent_type}",
+                truncate(json.dumps(result, default=str)),
+                1,
+                project_path,
+            ),
+        )
+
+        # Update or create agent record
+        cursor.execute(
+            """
+            INSERT INTO agents (id, name, type, first_seen, last_seen, total_activities)
+            VALUES (?, ?, ?, ?, ?, 1)
+            ON CONFLICT(id) DO UPDATE SET
+                last_seen = ?,
+                total_activities = total_activities + 1
+            """,
+            (subagent_id, None, "subagent", now, now, now),
+        )
+
+        conn.commit()
+        conn.close()
+
+        print(json.dumps({}))
+
+    except Exception as e:
+        # Hooks should never block
+        print(json.dumps({"systemMessage": f"Cortex subagent_stop: {e}"}))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

omni_cortex/_bundled/hooks/user_prompt.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""UserPromptSubmit hook - captures user messages for style analysis.
+
+This hook is called by Claude Code when the user submits a prompt.
+It logs the user message to the Cortex database for later style analysis.
+
+Hook configuration for settings.json:
+{
+    "hooks": {
+        "UserPromptSubmit": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "python hooks/user_prompt.py"
+                    }
+                ]
+            }
+        ]
+    }
+}
+"""
+
+import json
+import re
+import sys
+import os
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+
+# Import shared session management
+from session_utils import get_or_create_session
+
+
+def get_db_path() -> Path:
+    """Get the database path for the current project."""
+    project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+    return Path(project_path) / ".omni-cortex" / "cortex.db"
+
+
+def ensure_database(db_path: Path) -> sqlite3.Connection:
+    """Ensure database exists and has user_messages table."""
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(db_path))
+
+    # Check if user_messages table exists
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='user_messages'")
+    if cursor.fetchone() is None:
+        # Apply minimal schema for user_messages
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS user_messages (
+                id TEXT PRIMARY KEY,
+                session_id TEXT,
+                timestamp TEXT NOT NULL,
+                content TEXT NOT NULL,
+                word_count INTEGER,
+                char_count INTEGER,
+                line_count INTEGER,
+                has_code_blocks INTEGER DEFAULT 0,
+                has_questions INTEGER DEFAULT 0,
+                has_commands INTEGER DEFAULT 0,
+                tone_indicators TEXT,
+                project_path TEXT,
+                metadata TEXT
+            );
+            CREATE INDEX IF NOT EXISTS idx_user_messages_timestamp ON user_messages(timestamp DESC);
+        """)
+        conn.commit()
+
+    return conn
+
+
+def generate_id() -> str:
+    """Generate a unique message ID."""
+    timestamp_ms = int(datetime.now().timestamp() * 1000)
+    random_hex = os.urandom(4).hex()
+    return f"msg_{timestamp_ms}_{random_hex}"
+
+
+def analyze_message(content: str) -> dict:
+    """Analyze message characteristics for style profiling."""
+    # Basic counts
+    word_count = len(content.split())
+    char_count = len(content)
+    line_count = len(content.splitlines()) or 1
+
+    # Detect code blocks
+    has_code_blocks = 1 if re.search(r'```[\s\S]*?```|`[^`]+`', content) else 0
+
+    # Detect questions
+    has_questions = 1 if re.search(r'\?|^(what|how|why|when|where|who|which|can|could|would|should|is|are|do|does|did)\b', content, re.IGNORECASE | re.MULTILINE) else 0
+
+    # Detect slash commands
+    has_commands = 1 if content.strip().startswith('/') else 0
+
+    # Tone indicators
+    tone_indicators = []
+
+    # Urgency markers
+    if re.search(r'\b(urgent|asap|immediately|quick|fast|hurry)\b', content, re.IGNORECASE):
+        tone_indicators.append("urgent")
+
+    # Polite markers
+    if re.search(r'\b(please|thanks|thank you|appreciate|kindly)\b', content, re.IGNORECASE):
+        tone_indicators.append("polite")
+
+    # Direct/imperative
+    if re.match(r'^(fix|add|remove|update|change|create|delete|run|test|check|show|list|find)\b', content.strip(), re.IGNORECASE):
+        tone_indicators.append("direct")
+
+    # Questioning/exploratory
+    if has_questions:
+        tone_indicators.append("inquisitive")
+
+    # Technical
+    if re.search(r'\b(function|class|method|variable|api|database|server|error|bug|issue)\b', content, re.IGNORECASE):
+        tone_indicators.append("technical")
+
+    # Casual
+    if re.search(r'\b(hey|hi|yo|cool|awesome|great|nice)\b', content, re.IGNORECASE):
+        tone_indicators.append("casual")
+
+    return {
+        "word_count": word_count,
+        "char_count": char_count,
+        "line_count": line_count,
+        "has_code_blocks": has_code_blocks,
+        "has_questions": has_questions,
+        "has_commands": has_commands,
+        "tone_indicators": json.dumps(tone_indicators),
+    }
+
+
+def main():
+    """Process UserPromptSubmit hook."""
+    try:
+        # Read input from stdin
+        import select
+        if sys.platform != "win32":
+            ready, _, _ = select.select([sys.stdin], [], [], 5.0)
+            if not ready:
+                print(json.dumps({}))
+                return
+
+        raw_input = sys.stdin.read()
+        if not raw_input or not raw_input.strip():
+            print(json.dumps({}))
+            return
+
+        input_data = json.loads(raw_input)
+
+        # Extract user prompt
+        prompt = input_data.get("prompt", "")
+        if not prompt or not prompt.strip():
+            print(json.dumps({}))
+            return
+
+        # Skip very short messages (likely just commands)
+        if len(prompt.strip()) < 3:
+            print(json.dumps({}))
+            return
+
+        project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+
+        # Initialize database
+        db_path = get_db_path()
+        conn = ensure_database(db_path)
+
+        # Get or create session
+        session_id = get_or_create_session(conn, project_path)
+
+        # Analyze message
+        analysis = analyze_message(prompt)
+
+        # Generate message ID
+        message_id = generate_id()
+
+        # Insert message record
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            INSERT INTO user_messages (
+                id, session_id, timestamp, content, word_count, char_count,
+                line_count, has_code_blocks, has_questions, has_commands,
+                tone_indicators, project_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                message_id,
+                session_id,
+                datetime.now(timezone.utc).isoformat(),
+                prompt,
+                analysis["word_count"],
+                analysis["char_count"],
+                analysis["line_count"],
+                analysis["has_code_blocks"],
+                analysis["has_questions"],
+                analysis["has_commands"],
+                analysis["tone_indicators"],
+                project_path,
+            ),
+        )
+        conn.commit()
+        conn.close()
+
+        # Return empty response (don't modify prompt)
+        print(json.dumps({}))
+
+    except Exception as e:
+        # Hooks should never block - log error but continue
+        # Don't print system message to avoid polluting user experience
+        print(json.dumps({}))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

omni_cortex/categorization/__init__.py

@@ -0,0 +1,9 @@
+"""Auto-categorization for memories."""
+
+from .auto_type import detect_memory_type
+from .auto_tags import suggest_tags
+
+__all__ = [
+    "detect_memory_type",
+    "suggest_tags",
+]

omni_cortex/categorization/auto_tags.py

@@ -0,0 +1,166 @@
+"""Auto-suggest tags based on content."""
+
+import re
+from typing import Optional
+
+# Tag patterns organized by category
+TAG_PATTERNS: dict[str, list[tuple[str, str]]] = {
+    # Programming languages
+    "languages": [
+        (r"\b(python|\.py)\b", "python"),
+        (r"\b(javascript|\.js|\.jsx)\b", "javascript"),
+        (r"\b(typescript|\.ts|\.tsx)\b", "typescript"),
+        (r"\b(rust|\.rs|cargo)\b", "rust"),
+        (r"\b(go|golang|\.go)\b", "go"),
+        (r"\b(java|\.java)\b", "java"),
+        (r"\b(c\+\+|cpp|\.cpp|\.hpp)\b", "cpp"),
+        (r"\b(c#|csharp|\.cs)\b", "csharp"),
+        (r"\b(ruby|\.rb)\b", "ruby"),
+        (r"\b(php|\.php)\b", "php"),
+        (r"\b(swift|\.swift)\b", "swift"),
+        (r"\b(kotlin|\.kt)\b", "kotlin"),
+        (r"\b(sql|mysql|postgres|sqlite)\b", "sql"),
+        (r"\b(html|\.html)\b", "html"),
+        (r"\b(css|\.css|scss|sass)\b", "css"),
+        (r"\b(shell|bash|\.sh|zsh)\b", "shell"),
+    ],
+    # Frameworks and libraries
+    "frameworks": [
+        (r"\b(react|reactjs|jsx)\b", "react"),
+        (r"\b(vue|vuejs)\b", "vue"),
+        (r"\b(angular)\b", "angular"),
+        (r"\b(svelte)\b", "svelte"),
+        (r"\b(nextjs|next\.js)\b", "nextjs"),
+        (r"\b(express|expressjs)\b", "express"),
+        (r"\b(fastapi)\b", "fastapi"),
+        (r"\b(django)\b", "django"),
+        (r"\b(flask)\b", "flask"),
+        (r"\b(spring)\b", "spring"),
+        (r"\b(rails|ruby on rails)\b", "rails"),
+        (r"\b(laravel)\b", "laravel"),
+        (r"\b(tailwind|tailwindcss)\b", "tailwind"),
+        (r"\b(bootstrap)\b", "bootstrap"),
+    ],
+    # Tools and platforms
+    "tools": [
+        (r"\b(git|github|gitlab)\b", "git"),
+        (r"\b(docker|dockerfile|container)\b", "docker"),
+        (r"\b(kubernetes|k8s|kubectl)\b", "kubernetes"),
+        (r"\b(aws|amazon web services|s3|ec2|lambda)\b", "aws"),
+        (r"\b(gcp|google cloud)\b", "gcp"),
+        (r"\b(azure|microsoft azure)\b", "azure"),
+        (r"\b(terraform)\b", "terraform"),
+        (r"\b(jenkins|ci\/cd|github actions)\b", "ci-cd"),
+        (r"\b(npm|yarn|pnpm)\b", "npm"),
+        (r"\b(pip|poetry|pipenv)\b", "pip"),
+        (r"\b(vscode|visual studio code)\b", "vscode"),
+        (r"\b(vim|neovim)\b", "vim"),
+    ],
+    # Concepts
+    "concepts": [
+        (r"\b(api|rest|graphql|endpoint)\b", "api"),
+        (r"\b(database|db|query|schema)\b", "database"),
+        (r"\b(auth|authentication|authorization|oauth|jwt)\b", "auth"),
+        (r"\b(testing|test|unittest|pytest|jest)\b", "testing"),
+        (r"\b(security|vulnerability|xss|csrf|injection)\b", "security"),
+        (r"\b(performance|optimization|cache|speed)\b", "performance"),
+        (r"\b(deploy|deployment|release)\b", "deployment"),
+        (r"\b(debug|debugging|breakpoint)\b", "debugging"),
+        (r"\b(error handling|exception|try catch)\b", "error-handling"),
+        (r"\b(async|await|promise|concurrent)\b", "async"),
+        (r"\b(regex|regular expression)\b", "regex"),
+        (r"\b(json|yaml|xml|toml)\b", "config-format"),
+    ],
+    # Project-specific
+    "project": [
+        (r"\b(frontend|front-end|ui)\b", "frontend"),
+        (r"\b(backend|back-end|server)\b", "backend"),
+        (r"\b(fullstack|full-stack)\b", "fullstack"),
+        (r"\b(cli|command line|terminal)\b", "cli"),
+        (r"\b(mobile|ios|android|react native)\b", "mobile"),
+        (r"\b(web|website|webapp)\b", "web"),
+    ],
+}
+
+# Compile patterns
+_compiled_patterns: list[tuple[re.Pattern, str]] = []
+
+
+def _ensure_compiled() -> None:
+    """Ensure patterns are compiled."""
+    global _compiled_patterns
+    if not _compiled_patterns:
+        for category_patterns in TAG_PATTERNS.values():
+            for pattern, tag in category_patterns:
+                _compiled_patterns.append((
+                    re.compile(pattern, re.IGNORECASE),
+                    tag
+                ))
+
+
+def suggest_tags(
+    content: str,
+    context: Optional[str] = None,
+    max_tags: int = 5
+) -> list[str]:
+    """Suggest tags based on content analysis.
+
+    Args:
+        content: The memory content
+        context: Optional context string
+        max_tags: Maximum number of tags to suggest
+
+    Returns:
+        List of suggested tag strings
+    """
+    _ensure_compiled()
+
+    if not content:
+        return []
+
+    text = content.lower()
+    if context:
+        text = f"{text}\n{context.lower()}"
+
+    # Track tag occurrence counts
+    tag_counts: dict[str, int] = {}
+
+    for pattern, tag in _compiled_patterns:
+        matches = pattern.findall(text)
+        if matches:
+            tag_counts[tag] = tag_counts.get(tag, 0) + len(matches)
+
+    # Sort by count and return top tags
+    sorted_tags = sorted(tag_counts.items(), key=lambda x: x[1], reverse=True)
+    return [tag for tag, _ in sorted_tags[:max_tags]]
+
+
+def merge_tags(
+    existing: list[str],
+    suggested: list[str],
+    user_provided: Optional[list[str]] = None
+) -> list[str]:
+    """Merge tag lists, removing duplicates.
+
+    Args:
+        existing: Existing tags on the memory
+        suggested: Auto-suggested tags
+        user_provided: Tags explicitly provided by user
+
+    Returns:
+        Merged list of unique tags
+    """
+    # Start with user-provided tags (highest priority)
+    result = list(user_provided or [])
+
+    # Add existing tags
+    for tag in existing:
+        if tag not in result:
+            result.append(tag)
+
+    # Add suggested tags
+    for tag in suggested:
+        if tag not in result:
+            result.append(tag)
+
+    return result

omni_cortex/categorization/auto_type.py

@@ -0,0 +1,165 @@
+"""Auto-detect memory type based on content."""
+
+import re
+from typing import Optional
+
+# Memory types
+MEMORY_TYPES = [
+    "warning",
+    "tip",
+    "config",
+    "troubleshooting",
+    "code",
+    "error",
+    "solution",
+    "command",
+    "concept",
+    "decision",
+    "general",
+]
+
+# Pattern definitions for each type (case-insensitive)
+TYPE_PATTERNS: dict[str, list[str]] = {
+    "warning": [
+        r"\b(warning|caution|don't|dont|avoid|never|careful|danger|risk)\b",
+        r"\b(do not|should not|shouldn't|mustn't|must not)\b",
+        r"\b(beware|watch out|important note)\b",
+    ],
+    "tip": [
+        r"\b(tip|trick|best practice|recommend|suggestion|pro tip)\b",
+        r"\b(you can|try|consider|it's better|better to)\b",
+        r"\b(shortcut|hack|optimization|improve)\b",
+    ],
+    "config": [
+        r"\b(config|configuration|setting|setup|environment|env)\b",
+        r"\b(\.env|\.yaml|\.json|\.toml|\.ini)\b",
+        r"\b(variable|parameter|option|flag)\b",
+        r"(API_KEY|DATABASE_URL|SECRET|TOKEN)",
+    ],
+    "troubleshooting": [
+        r"\b(fix|solve|debug|troubleshoot|resolve|workaround)\b",
+        r"\b(issue|problem|bug|broken|not working)\b",
+        r"\b(symptoms?|cause|root cause)\b",
+    ],
+    "code": [
+        r"```[\w]*\n",  # Code block
+        r"\b(function|def|class|const|let|var|import|export)\s+\w+",
+        r"\b(async|await|return|yield)\b",
+        r"^\s*(public|private|protected)\s+",
+    ],
+    "error": [
+        r"\b(error|exception|failed|failure|crash)\b",
+        r"\b(traceback|stack trace|line \d+)\b",
+        r"\b(TypeError|ValueError|ImportError|SyntaxError)\b",
+        r"\b(500|404|403|401)\s+(error|status)\b",
+    ],
+    "solution": [
+        r"\b(solution|solved|fixed|resolved|works?)\b",
+        r"\b(answer|resolution|the fix|working now)\b",
+        r"\b(here's how|the way to|correct approach)\b",
+    ],
+    "command": [
+        r"^\s*[$>]\s+\S+",  # Shell prompt
+        r"\b(npm|pip|git|docker|kubectl|yarn|pnpm)\s+\w+",
+        r"\b(run|install|build|start|test|deploy)\s+",
+        r"^(curl|wget|ssh|scp)\s+",
+    ],
+    "concept": [
+        r"\b(is|are|means|defined as|refers to)\b",
+        r"\b(concept|definition|explanation|understanding)\b",
+        r"\b(basically|essentially|in other words)\b",
+    ],
+    "decision": [
+        r"\b(decided|decision|approach|choice|chose|choosing)\b",
+        r"\b(we will|going to|plan to|opted for)\b",
+        r"\b(strategy|architecture|design|pattern)\b",
+    ],
+}
+
+# Compiled patterns (case-insensitive)
+_compiled_patterns: dict[str, list[re.Pattern]] = {}
+
+
+def _get_patterns(mem_type: str) -> list[re.Pattern]:
+    """Get compiled patterns for a memory type."""
+    if mem_type not in _compiled_patterns:
+        patterns = TYPE_PATTERNS.get(mem_type, [])
+        _compiled_patterns[mem_type] = [
+            re.compile(p, re.IGNORECASE | re.MULTILINE)
+            for p in patterns
+        ]
+    return _compiled_patterns[mem_type]
+
+
+def detect_memory_type(content: str, context: Optional[str] = None) -> str:
+    """Detect the most likely memory type from content.
+
+    Args:
+        content: The memory content
+        context: Optional context string
+
+    Returns:
+        Memory type string
+    """
+    if not content:
+        return "general"
+
+    # Combine content and context for analysis
+    text = content
+    if context:
+        text = f"{content}\n{context}"
+
+    # Track match scores
+    scores: dict[str, int] = {t: 0 for t in MEMORY_TYPES if t != "general"}
+
+    # Check each type's patterns
+    for mem_type, patterns in TYPE_PATTERNS.items():
+        for pattern in _get_patterns(mem_type):
+            matches = pattern.findall(text)
+            if matches:
+                scores[mem_type] += len(matches)
+
+    # Find the type with highest score
+    if scores:
+        best_type = max(scores.items(), key=lambda x: x[1])
+        if best_type[1] > 0:
+            return best_type[0]
+
+    return "general"
+
+
+def get_type_confidence(content: str, context: Optional[str] = None) -> dict[str, float]:
+    """Get confidence scores for each memory type.
+
+    Args:
+        content: The memory content
+        context: Optional context string
+
+    Returns:
+        Dictionary of type -> confidence (0.0 to 1.0)
+    """
+    if not content:
+        return {"general": 1.0}
+
+    text = content
+    if context:
+        text = f"{content}\n{context}"
+
+    # Track raw scores
+    scores: dict[str, int] = {t: 0 for t in MEMORY_TYPES if t != "general"}
+
+    for mem_type, patterns in TYPE_PATTERNS.items():
+        for pattern in _get_patterns(mem_type):
+            matches = pattern.findall(text)
+            scores[mem_type] += len(matches)
+
+    # Normalize to confidence
+    total = sum(scores.values())
+    if total == 0:
+        return {"general": 1.0}
+
+    confidences = {t: s / total for t, s in scores.items() if s > 0}
+    if not confidences:
+        return {"general": 1.0}
+
+    return confidences