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

omni_cortex-1.17.5.dist-info/RECORD

@@ -0,0 +1,53 @@
+omni_cortex/_bundled/hooks/post_tool_use.py,sha256=nr9u8V0_NHsieWUcgRbSW7cQWczgP-mUtF9A4_RgZPw,16674
+omni_cortex/_bundled/hooks/pre_tool_use.py,sha256=VUslRSY9S3hbXWShFcjXl5GfEcOwsSADvMHh0TE_7PQ,8678
+omni_cortex/_bundled/hooks/session_utils.py,sha256=3SKPCytqWuRPOupWdzmwBoKBDJqtLcT1Nle_pueDQUY,5746
+omni_cortex/_bundled/hooks/stop.py,sha256=IZco1xWp8v02Kmb9RUzE0oM16HCcviL48GX0wKIxiRE,7077
+omni_cortex/_bundled/hooks/subagent_stop.py,sha256=D2JPGhWlBjQNX5iDnRxP2saPKsVLoPVZUWVaIrK9G5w,3415
+omni_cortex/_bundled/hooks/user_prompt.py,sha256=jBQkJHs6H6zYYsL-RHq2oQ3gyGf8gx7virQ8SE0rF_g,10911
+omni_cortex/_bundled/dashboard/backend/.env.example,sha256=9xS7-UiWlMddRwzlyyyKNHAMlNTsgH-2sPV266guJpQ,372
+omni_cortex/_bundled/dashboard/backend/backfill_summaries.py,sha256=ElchfcBv4pmVr2PsePCgFlCyuvf4_jDJj_C3AmMhu7U,8973
+omni_cortex/_bundled/dashboard/backend/chat_service.py,sha256=iEDpAw8OVaHM2312VPcAM-w6dYabUpjaTvWl1jGhqi0,20948
+omni_cortex/_bundled/dashboard/backend/database.py,sha256=byISCVgVziqFhJ8j8FC99ueTAoo-E0BJ6bk8KUvW3Mg,57610
+omni_cortex/_bundled/dashboard/backend/image_service.py,sha256=NP6ojFpHb6iNTYRkXqYu1CL6WvooZpZ54mjLiWSWG_g,19205
+omni_cortex/_bundled/dashboard/backend/logging_config.py,sha256=WnunFGET9zlsn9WBpVsio2zI7BiUQanE0xzAQQxIhII,3944
+omni_cortex/_bundled/dashboard/backend/main.py,sha256=vfNQQOL-KEVg1NV-XTlweA3lQqRaQxaT2-lQx5Z4ZEs,67238
+omni_cortex/_bundled/dashboard/backend/models.py,sha256=mP_szTXuVE4ZWHGubLeCt1-ltroO8OO0vrGC3IM6AJ0,13122
+omni_cortex/_bundled/dashboard/backend/project_config.py,sha256=ZxGoeRpHvN5qQyf2hRxrAZiHrPSwdQp59f0di6O1LKM,4352
+omni_cortex/_bundled/dashboard/backend/project_scanner.py,sha256=lwFXS8iJbOoxf7FAyo2TjH25neaMHiJ8B3jS57XxtDI,5713
+omni_cortex/_bundled/dashboard/backend/prompt_security.py,sha256=LcdZhYy1CfpSq_4BPO6lMJ15phc2ZXLUSBAnAvODVCI,3423
+omni_cortex/_bundled/dashboard/backend/pyproject.toml,sha256=9pbbGQXLe1Xd06nZAtDySCHIlfMWvPaB-C6tGZR6umc,502
+omni_cortex/_bundled/dashboard/backend/security.py,sha256=nQsoPE0n5dtY9ive00d33W1gL48GgK7C5Ae0BK2oW2k,3479
+omni_cortex/_bundled/dashboard/backend/test_database.py,sha256=Zcu5rgz1iprnzEANo5MIPgK7mwF97Prerp7QU4MjPfo,9504
+omni_cortex/_bundled/dashboard/backend/tmpclaude-2dfa-cwd,sha256=XAwk7miagzW8cn6LsjnPgONAMSxkRMWNapzJaOodR9Y,42
+omni_cortex/_bundled/dashboard/backend/tmpclaude-c460-cwd,sha256=XAwk7miagzW8cn6LsjnPgONAMSxkRMWNapzJaOodR9Y,42
+omni_cortex/_bundled/dashboard/backend/uv.lock,sha256=miB9zGGSirBkjDE-OZTPCnv43Yc98xuAz_Ne8vTNFHg,186004
+omni_cortex/_bundled/dashboard/backend/websocket_manager.py,sha256=gNQLd94AcC-InumGQmUolREhiogCzilYWpLN8SRZjHI,3645
+omni_cortex/_bundled/dashboard/frontend/dist/index.html,sha256=eN9-5y-KTvQ5BHs-Bh7fJO0WW5uh3unBHPLxzlKhc58,503
+omni_cortex/_bundled/dashboard/frontend/dist/assets/index-CQlQK3nE.js,sha256=3vBwHNt62Xf9mO4REkQ1cXcQirRjLYEi8V6EbYZKi48,724613
+omni_cortex/_bundled/dashboard/frontend/dist/assets/index-CmUNNfe4.css,sha256=_8e4zs4P6JHjtpr7K7jE90_X0c2TgvSOALngsQNlXDA,77476
+omni_cortex-1.17.5.data/data/share/omni-cortex/hooks/post_tool_use.py,sha256=nr9u8V0_NHsieWUcgRbSW7cQWczgP-mUtF9A4_RgZPw,16674
+omni_cortex-1.17.5.data/data/share/omni-cortex/hooks/pre_tool_use.py,sha256=VUslRSY9S3hbXWShFcjXl5GfEcOwsSADvMHh0TE_7PQ,8678
+omni_cortex-1.17.5.data/data/share/omni-cortex/hooks/session_utils.py,sha256=3SKPCytqWuRPOupWdzmwBoKBDJqtLcT1Nle_pueDQUY,5746
+omni_cortex-1.17.5.data/data/share/omni-cortex/hooks/stop.py,sha256=IZco1xWp8v02Kmb9RUzE0oM16HCcviL48GX0wKIxiRE,7077
+omni_cortex-1.17.5.data/data/share/omni-cortex/hooks/subagent_stop.py,sha256=D2JPGhWlBjQNX5iDnRxP2saPKsVLoPVZUWVaIrK9G5w,3415
+omni_cortex-1.17.5.data/data/share/omni-cortex/hooks/user_prompt.py,sha256=jBQkJHs6H6zYYsL-RHq2oQ3gyGf8gx7virQ8SE0rF_g,10911
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/.env.example,sha256=9xS7-UiWlMddRwzlyyyKNHAMlNTsgH-2sPV266guJpQ,372
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/backfill_summaries.py,sha256=ElchfcBv4pmVr2PsePCgFlCyuvf4_jDJj_C3AmMhu7U,8973
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/chat_service.py,sha256=iEDpAw8OVaHM2312VPcAM-w6dYabUpjaTvWl1jGhqi0,20948
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/database.py,sha256=byISCVgVziqFhJ8j8FC99ueTAoo-E0BJ6bk8KUvW3Mg,57610
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/image_service.py,sha256=NP6ojFpHb6iNTYRkXqYu1CL6WvooZpZ54mjLiWSWG_g,19205
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/logging_config.py,sha256=WnunFGET9zlsn9WBpVsio2zI7BiUQanE0xzAQQxIhII,3944
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/main.py,sha256=vfNQQOL-KEVg1NV-XTlweA3lQqRaQxaT2-lQx5Z4ZEs,67238
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/models.py,sha256=mP_szTXuVE4ZWHGubLeCt1-ltroO8OO0vrGC3IM6AJ0,13122
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/project_config.py,sha256=ZxGoeRpHvN5qQyf2hRxrAZiHrPSwdQp59f0di6O1LKM,4352
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/project_scanner.py,sha256=lwFXS8iJbOoxf7FAyo2TjH25neaMHiJ8B3jS57XxtDI,5713
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/prompt_security.py,sha256=LcdZhYy1CfpSq_4BPO6lMJ15phc2ZXLUSBAnAvODVCI,3423
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/pyproject.toml,sha256=9pbbGQXLe1Xd06nZAtDySCHIlfMWvPaB-C6tGZR6umc,502
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/security.py,sha256=nQsoPE0n5dtY9ive00d33W1gL48GgK7C5Ae0BK2oW2k,3479
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/uv.lock,sha256=miB9zGGSirBkjDE-OZTPCnv43Yc98xuAz_Ne8vTNFHg,186004
+omni_cortex-1.17.5.data/data/share/omni-cortex/dashboard/backend/websocket_manager.py,sha256=gNQLd94AcC-InumGQmUolREhiogCzilYWpLN8SRZjHI,3645
+omni_cortex-1.17.5.dist-info/METADATA,sha256=rUSSZrui9ztbDbAs673qN5lBd9d0W_o-eCnnAex9mds,15962
+omni_cortex-1.17.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+omni_cortex-1.17.5.dist-info/entry_points.txt,sha256=rohx4mFH2ffZmMb9QXPZmFf-ZGjA3jpKVDVeET-ttiM,150
+omni_cortex-1.17.5.dist-info/licenses/LICENSE,sha256=oG_397owMmi-Umxp5sYocJ6RPohp9_bDNnnEu9OUphg,1072
+omni_cortex-1.17.5.dist-info/RECORD,,

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)