omni-cortex 1.17.2__py3-none-any.whl → 1.17.4__py3-none-any.whl

omni_cortex/__init__.py

@@ -1,3 +0,0 @@
-"""Omni Cortex MCP - Universal Memory System for Claude Code."""
-
-__version__ = "1.17.1"

omni_cortex/categorization/__init__.py

@@ -1,9 +0,0 @@
-"""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

@@ -1,166 +0,0 @@
-"""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

@@ -1,165 +0,0 @@
-"""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

omni_cortex/config.py

@@ -1,141 +0,0 @@
-"""Configuration management for Omni Cortex."""
-
-import os
-from pathlib import Path
-from typing import Optional
-from dataclasses import dataclass, field
-
-import yaml
-
-
-@dataclass
-class CortexConfig:
-    """Configuration settings for Omni Cortex."""
-
-    # Database
-    schema_version: str = "1.0"
-
-    # Embedding (disabled by default - model loading can be slow)
-    embedding_model: str = "all-MiniLM-L6-v2"
-    embedding_enabled: bool = False
-
-    # Decay
-    decay_rate_per_day: float = 0.5
-    freshness_review_days: int = 30
-
-    # Output
-    max_output_truncation: int = 10000
-    max_tool_input_size: int = 10000
-
-    # Session
-    auto_provide_context: bool = True
-    context_depth: int = 3
-
-    # Search (default to keyword since embeddings are disabled by default)
-    default_search_mode: str = "keyword"
-
-    # Global
-    global_sync_enabled: bool = True
-    api_fallback_enabled: bool = False
-    api_key: str = ""
-
-
-def get_project_path() -> Path:
-    """Get the current project path from environment or cwd."""
-    return Path(os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd()))
-
-
-def get_project_db_dir() -> Path:
-    """Get the project-local .omni-cortex directory."""
-    return get_project_path() / ".omni-cortex"
-
-
-def get_project_db_path() -> Path:
-    """Get the path to the project database."""
-    return get_project_db_dir() / "cortex.db"
-
-
-def get_global_db_dir() -> Path:
-    """Get the global ~/.omni-cortex directory."""
-    return Path.home() / ".omni-cortex"
-
-
-def get_global_db_path() -> Path:
-    """Get the path to the global database."""
-    return get_global_db_dir() / "global.db"
-
-
-def get_session_id() -> Optional[str]:
-    """Get the current session ID from environment."""
-    return os.environ.get("CLAUDE_SESSION_ID")
-
-
-def load_config(project_path: Optional[Path] = None) -> CortexConfig:
-    """Load configuration from project and global config files.
-
-    Priority: project config > global config > defaults
-    """
-    config = CortexConfig()
-
-    # Load global config
-    global_config_path = get_global_db_dir() / "config.yaml"
-    if global_config_path.exists():
-        try:
-            with open(global_config_path, "r") as f:
-                global_cfg = yaml.safe_load(f) or {}
-                _apply_config(config, global_cfg)
-        except Exception:
-            pass
-
-    # Load project config
-    if project_path is None:
-        project_path = get_project_path()
-    project_config_path = project_path / ".omni-cortex" / "config.yaml"
-    if project_config_path.exists():
-        try:
-            with open(project_config_path, "r") as f:
-                project_cfg = yaml.safe_load(f) or {}
-                _apply_config(config, project_cfg)
-        except Exception:
-            pass
-
-    return config
-
-
-def _apply_config(config: CortexConfig, data: dict) -> None:
-    """Apply configuration data to config object."""
-    for key, value in data.items():
-        if hasattr(config, key) and value is not None:
-            setattr(config, key, value)
-
-
-def save_config(config: CortexConfig, project: bool = True) -> None:
-    """Save configuration to file.
-
-    Args:
-        config: Configuration to save
-        project: If True, save to project config; otherwise global
-    """
-    if project:
-        config_dir = get_project_db_dir()
-    else:
-        config_dir = get_global_db_dir()
-
-    config_dir.mkdir(parents=True, exist_ok=True)
-    config_path = config_dir / "config.yaml"
-
-    data = {
-        "schema_version": config.schema_version,
-        "embedding_model": config.embedding_model,
-        "embedding_enabled": config.embedding_enabled,
-        "decay_rate_per_day": config.decay_rate_per_day,
-        "freshness_review_days": config.freshness_review_days,
-        "max_output_truncation": config.max_output_truncation,
-        "auto_provide_context": config.auto_provide_context,
-        "context_depth": config.context_depth,
-        "default_search_mode": config.default_search_mode,
-        "global_sync_enabled": config.global_sync_enabled,
-    }
-
-    with open(config_path, "w") as f:
-        yaml.dump(data, f, default_flow_style=False)