mdinject 0.2.0__py3-none-any.whl

mdinject/__init__.py

@@ -0,0 +1,7 @@
+"""MdInject - Markdown prompt injection for CLI tools.
+
+A SwiftUI desktop application for managing and injecting markdown prompts
+into terminal-based CLI tools like Claude Code, Codex, Vibe, and Qwen.
+"""
+
+__version__ = "0.1.0"

mdinject/__main__.py

@@ -0,0 +1,270 @@
+"""MdInject command-line interface with Oneiric integration.
+
+This module provides the CLI entry point for mdinject with full Oneiric
+integration including configuration management, structured logging,
+and adapter lifecycle management.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from typing import Any
+
+from oneiric.core.lifecycle import LifecycleManager
+from oneiric.core.resolution import Candidate, Resolver
+
+from . import __version__
+from .adapters import PromptStorageAdapter
+from .config import (
+    MdInjectConfig,
+    get_config_paths,
+    load_app_config,
+)
+from .logging import clear_context, get_logger, scoped_context, setup_logging
+
+
+class MdInjectApplication:
+    """Main application class with Oneiric integration.
+
+    This class manages the application lifecycle including configuration,
+    logging, adapter registration, and graceful shutdown.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the application."""
+        self._config: MdInjectConfig | None = None
+        self._resolver: Resolver | None = None
+        self._lifecycle: LifecycleManager | None = None
+        # The bound structlog logger doesn't have a precise type that ty
+        # can resolve, so type it loosely and narrow at use sites.
+        self._logger: Any = None
+        self._storage: PromptStorageAdapter | None = None
+
+    async def startup(self) -> None:
+        """Initialize the application.
+
+        This method:
+        1. Loads configuration
+        2. Sets up structured logging
+        3. Initializes Oneiric resolver
+        4. Registers mdinject adapters
+        5. Creates lifecycle manager
+        6. Activates storage adapter
+        7. Performs health checks
+        """
+        # Load configuration
+        self._config = load_app_config()
+        paths = get_config_paths()
+
+        # Setup structured logging
+        setup_logging(
+            level="DEBUG" if self._config.debug else "INFO",
+            development=self._config.debug,
+            log_file=paths["cache"] / "mdinject.log",
+            service_name="mdinject",
+        )
+
+        self._logger = get_logger("mdinject.app").bind(
+            version=__version__,
+            environment=self._config.environment,
+        )
+
+        with scoped_context(phase="startup"):
+            self._logger.info("application_startup", config_path=str(paths["config"]))
+
+            # Initialize Oneiric resolver
+            self._resolver = Resolver()
+            await self._register_adapters()
+
+            # Create lifecycle manager
+            self._lifecycle = LifecycleManager(resolver=self._resolver)
+
+            # Activate storage adapter
+            await self._activate_storage()
+
+            # Perform health checks
+            await self._health_check()
+
+    async def _register_adapters(self) -> None:
+        """Register mdinject adapters with the resolver.
+
+        This method registers all mdinject-specific adapters including
+        the prompt storage adapter.
+        """
+        assert self._logger is not None
+        assert self._resolver is not None
+
+        self._logger.info("registering_adapters")
+
+        # Register prompt storage adapter
+        # The adapter class itself contains metadata via @property
+        storage_adapter = PromptStorageAdapter()
+        self._resolver.register(
+            Candidate(
+                domain="adapter",
+                key="prompt_store",
+                provider=storage_adapter.metadata.provider,
+                factory=PromptStorageAdapter,
+                priority=storage_adapter.metadata.priority,
+                metadata=storage_adapter.metadata.model_dump(),
+            )
+        )
+
+        self._logger.debug(
+            "adapters_registered",
+            storage_provider=storage_adapter.metadata.provider,
+        )
+
+    async def _activate_storage(self) -> None:
+        """Activate the prompt storage adapter.
+
+        Raises:
+            RuntimeError: If storage adapter fails to activate or health check fails
+        """
+        assert self._config is not None
+        assert self._lifecycle is not None
+        assert self._logger is not None
+
+        self._logger.info(
+            "activating_storage",
+            provider=self._config.storage.adapter_provider,
+        )
+
+        try:
+            # Create storage adapter instance directly
+            # (bypassing resolver activation for direct control)
+            self._storage = PromptStorageAdapter()
+            await self._storage.init()
+
+            # Verify storage is healthy
+            is_healthy = await self._storage.health()
+            if not is_healthy:
+                raise RuntimeError("Storage adapter failed health check")
+
+            self._logger.info(
+                "storage_activated",
+                database_path=self._config.storage.database_path,
+            )
+
+        except Exception as e:
+            self._logger.error("storage_activation_failed", error=str(e))
+            raise RuntimeError(f"Failed to activate storage: {e}") from e
+
+    async def _health_check(self) -> None:
+        """Perform health checks on all active components.
+
+        Raises:
+            RuntimeError: If any critical component fails health check
+        """
+        assert self._logger is not None
+        assert self._storage is not None
+
+        self._logger.info("health_check_start")
+
+        # Check storage health
+        storage_healthy = await self._storage.health()
+        self._logger.info(
+            "health_check_result",
+            storage="healthy" if storage_healthy else "unhealthy",
+        )
+
+        if not storage_healthy:
+            raise RuntimeError("Storage health check failed")
+
+    async def run(self) -> None:
+        """Run the main application logic.
+
+        For the CLI interface, this simply lists the loaded prompts.
+        In a GUI application, this would start the Qt event loop.
+        """
+        assert self._logger is not None
+        assert self._storage is not None
+        assert self._config is not None
+
+        with scoped_context(phase="run"):
+            # List prompts from storage
+            prompts = await self._storage.list_prompts()
+
+            self._logger.info(
+                "prompts_loaded",
+                count=len(prompts),
+            )
+
+            # Print to console
+            print(f"MdInject {__version__} initialized.")
+            print(f"Environment: {self._config.environment}")
+            print(f"{len(prompts)} prompt(s) loaded.")
+            print(f"Database: {self._config.storage.database_path}")
+
+            # List prompt titles if any exist
+            if prompts:
+                print("\nPrompts:")
+                for prompt in prompts:
+                    print(f"  - {prompt.title}")
+
+    async def shutdown(self) -> None:
+        """Gracefully shutdown the application.
+
+        This method:
+        1. Cleans up storage adapter
+        2. Clears logging context
+        """
+        if self._logger:
+            self._logger.info("application_shutdown")
+
+        # Cleanup storage
+        if self._storage:
+            try:
+                await self._storage.cleanup()
+            except (RuntimeError, OSError) as e:
+                if self._logger:
+                    self._logger.warning("storage_cleanup_error", error=str(e))
+                else:
+                    print(f"Warning: Storage cleanup error: {e}")
+
+        # Clear logging context
+        clear_context()
+
+
+async def _async_main() -> int:
+    """Async main entry point.
+
+    Returns:
+        Exit code (0 for success, non-zero for errors)
+    """
+    app = MdInjectApplication()
+
+    try:
+        await app.startup()
+        await app.run()
+        await app.shutdown()
+        return 0
+    except KeyboardInterrupt:
+        if app._logger:
+            app._logger.info("keyboard_interrupt")
+        print("\nInterrupted by user")
+        return 130  # Standard exit code for SIGINT
+    except (RuntimeError, OSError, ValueError) as e:
+        if app._logger:
+            app._logger.error("application_error", error=str(e))
+        print(f"Error: {e}")
+        return 1
+
+
+def main() -> None:
+    """Synchronous main entry point.
+
+    This function is called by the mdinject console script.
+    It runs the async main function in an event loop.
+    """
+    try:
+        exit_code = asyncio.run(_async_main())
+        sys.exit(exit_code)
+    except (RuntimeError, OSError, ValueError) as e:
+        print(f"Fatal error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

mdinject/adapters/__init__.py

@@ -0,0 +1,15 @@
+"""Oneiric adapters for mdinject.
+
+This package contains all Oneiric-compatible adapters for mdinject,
+following the adapter pattern with factory registration and validation.
+"""
+
+from .prompt_storage import PromptStorageAdapter, PromptStorageSettings
+from .sqlite_wrapper import SQLiteDatabaseAdapter, SQLiteDatabaseSettings
+
+__all__ = [
+    "PromptStorageAdapter",
+    "PromptStorageSettings",
+    "SQLiteDatabaseAdapter",
+    "SQLiteDatabaseSettings",
+]

mdinject/adapters/content_format.py

@@ -0,0 +1,356 @@
+"""Content format detection and conversion adapters.
+
+This module provides format detection, conversion, and related data
+structures for transforming various content formats to clean markdown.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class ContentFormat(Enum):
+    """Supported content formats for detection and conversion."""
+
+    MARKDOWN = "markdown"
+    HTML = "html"
+    PLAIN_TEXT = "plain_text"
+    CODE = "code"
+    UNKNOWN = "unknown"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+@dataclass
+class FormatInfo:
+    """Result of format detection.
+
+    Attributes:
+        format: The detected content format
+        confidence: Detection confidence from 0.0 to 1.0
+        language: Detected programming language (for CODE format)
+        metadata: Additional format-specific metadata
+    """
+
+    format: ContentFormat
+    confidence: float
+    language: str | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Validate confidence is in valid range."""
+        if not 0.0 <= self.confidence <= 1.0:
+            raise ValueError(
+                f"Confidence must be between 0.0 and 1.0, got {self.confidence}"
+            )
+
+
+# HTML detection patterns
+HTML_PATTERNS = [
+    re.compile(r"<\s*!DOCTYPE\s+html", re.IGNORECASE),
+    re.compile(r"<\s*html[^>]*>", re.IGNORECASE),
+    re.compile(r"<\s*head[^>]*>", re.IGNORECASE),
+    re.compile(r"<\s*body[^>]*>", re.IGNORECASE),
+    re.compile(r"<\s*div[^>]*>", re.IGNORECASE),
+    re.compile(r"<\s*p[\s>]", re.IGNORECASE),
+    re.compile(r"<\s*a\s+href", re.IGNORECASE),
+    re.compile(r"<\s*img[^>]*src", re.IGNORECASE),
+    re.compile(r"<\s*ul[^>]*>|<\s*ol[^>]*>", re.IGNORECASE),
+    re.compile(r"<\s*li[^>]*>", re.IGNORECASE),
+    re.compile(r"<\s*h[1-6][^>]*>", re.IGNORECASE),
+    re.compile(r"<\s*table[^>]*>", re.IGNORECASE),
+    re.compile(r"&[a-z]+;|&#\d+;", re.IGNORECASE),  # HTML entities
+]
+
+# Markdown detection patterns
+MARKDOWN_PATTERNS = [
+    re.compile(r"^#{1,6}\s+\S", re.MULTILINE),  # ATX headings
+    re.compile(r"^\S[^\n]*\n[-=]{3,}\s*$", re.MULTILINE),  # Setext headings
+    re.compile(r"\*\*[^*]+\*\*"),  # Bold
+    re.compile(r"\*[^*]+\*"),  # Italic
+    re.compile(r"_[^_]+_"),  # Italic underscore
+    re.compile(r"`[^`]+`"),  # Inline code
+    re.compile(r"```\w*[\s\S]*?```"),  # Fenced code blocks
+    re.compile(r"^\s*[-*+]\s+\S", re.MULTILINE),  # Unordered lists
+    re.compile(r"^\s*\d+\.\s+\S", re.MULTILINE),  # Ordered lists
+    re.compile(r"\[[^\]]+\]\([^)]+\)"),  # Links
+    re.compile(r"!\[[^\]]*\]\([^)]+\)"),  # Images
+    re.compile(r"^\s*>\s+\S", re.MULTILINE),  # Blockquotes
+    re.compile(r"^\s*---+\s*$", re.MULTILINE),  # Horizontal rules
+]
+
+# Programming language detection patterns
+LANGUAGE_PATTERNS = {
+    "python": [
+        re.compile(r"^\s*def\s+\w+\s*\(", re.MULTILINE),
+        re.compile(r"^\s*class\s+\w+[:\(]", re.MULTILINE),
+        re.compile(r"^\s*import\s+\w+", re.MULTILINE),
+        re.compile(r"^\s*from\s+\w+\s+import", re.MULTILINE),
+        re.compile(r":\s*#.+$", re.MULTILINE),  # Python comments
+        re.compile(r"if\s+__name__\s*==\s*['\"]__main__['\"]"),
+    ],
+    "javascript": [
+        re.compile(r"^\s*function\s+\w+\s*\(", re.MULTILINE),
+        re.compile(r"^\s*const\s+\w+\s*=", re.MULTILINE),
+        re.compile(r"^\s*let\s+\w+\s*=", re.MULTILINE),
+        re.compile(r"^\s*var\s+\w+\s*=", re.MULTILINE),
+        re.compile(r"=>\s*[{(]"),
+        re.compile(r"^\s*async\s+function", re.MULTILINE),
+        re.compile(r"console\.(log|error|warn)\s*\("),
+    ],
+    "typescript": [
+        re.compile(r"^\s*interface\s+\w+", re.MULTILINE),
+        re.compile(r"^\s*type\s+\w+\s*=", re.MULTILINE),
+        re.compile(r":\s*(string|number|boolean|any)\b"),
+        re.compile(r"<[A-Z]\w*>"),
+        re.compile(r"^\s*export\s+(interface|type|class|function)", re.MULTILINE),
+    ],
+    "rust": [
+        re.compile(r"^\s*fn\s+\w+", re.MULTILINE),
+        re.compile(r"^\s*let\s+mut?\s+\w+", re.MULTILINE),
+        re.compile(r"^\s*impl\s+\w+", re.MULTILINE),
+        re.compile(r"^\s*pub\s+(fn|struct|enum)", re.MULTILINE),
+        re.compile(r"^\s*use\s+\w+::", re.MULTILINE),
+        re.compile(r"->\s*\w+"),
+    ],
+    "go": [
+        re.compile(r"^\s*func\s+\w+", re.MULTILINE),
+        re.compile(r"^\s*func\s*\(\w+\s+\*?\w+\)", re.MULTILINE),
+        re.compile(r"^\s*package\s+\w+", re.MULTILINE),
+        re.compile(r"^\s*import\s*\(", re.MULTILINE),
+        re.compile(r":=\s*\w+"),
+    ],
+    "java": [
+        re.compile(r"^\s*public\s+class\s+\w+", re.MULTILINE),
+        re.compile(r"^\s*private\s+\w+\s+\w+", re.MULTILINE),
+        re.compile(r"^\s*public\s+static\s+void\s+main", re.MULTILINE),
+        re.compile(r"System\.(out|err)\.print"),
+    ],
+    "bash": [
+        re.compile(r"^#!/bin/(ba)?sh", re.MULTILINE),
+        re.compile(r"^\s*if\s+\[\[", re.MULTILINE),
+        re.compile(r"^\s*for\s+\w+\s+in", re.MULTILINE),
+        re.compile(r"\$\{\w+\}"),
+        re.compile(r"^\s*echo\s+", re.MULTILINE),
+    ],
+    "sql": [
+        re.compile(r"^\s*SELECT\s+", re.IGNORECASE | re.MULTILINE),
+        re.compile(r"^\s*INSERT\s+INTO", re.IGNORECASE | re.MULTILINE),
+        re.compile(r"^\s*UPDATE\s+\w+\s+SET", re.IGNORECASE | re.MULTILINE),
+        re.compile(r"^\s*CREATE\s+TABLE", re.IGNORECASE | re.MULTILINE),
+        re.compile(r"^\s*FROM\s+\w+", re.IGNORECASE | re.MULTILINE),
+    ],
+    "yaml": [
+        re.compile(r"^\s*\w+:\s*$", re.MULTILINE),
+        re.compile(r"^\s*-\s+\w+:", re.MULTILINE),
+        re.compile(r"^\s*---\s*$", re.MULTILINE),
+    ],
+    "json": [
+        re.compile(r'^\s*\{[\s\S]*"\w+"\s*:\s*', re.MULTILINE),
+        re.compile(r"^\s*\[[\s\S]*\]", re.MULTILINE),
+    ],
+    "toml": [
+        re.compile(r"^\s*\[\w+\]", re.MULTILINE),
+        re.compile(r"^\s*\[\[.+\]\]", re.MULTILINE),
+    ],
+}
+
+
+def detect_format(content: str) -> FormatInfo:
+    """Detect the format of content.
+
+    This function analyzes content to determine its likely format
+    (HTML, Markdown, Code, or plain text) using pattern matching.
+
+    Args:
+        content: The content to analyze
+
+    Returns:
+        FormatInfo with detected format, confidence, and metadata
+
+    Example:
+        ```python
+        info = detect_format("<html><body>Hello</body></html>")
+        assert info.format == ContentFormat.HTML
+        assert info.confidence > 0.8
+        ```
+    """
+    if not content or not content.strip():
+        return FormatInfo(format=ContentFormat.PLAIN_TEXT, confidence=1.0)
+
+    stripped = content.strip()
+
+    # Check for HTML first (most distinctive patterns)
+    html_score = _score_html(stripped)
+    if html_score >= 0.7:
+        return FormatInfo(
+            format=ContentFormat.HTML,
+            confidence=html_score,
+            metadata={"html_score": html_score},
+        )
+
+    # Check for code with language detection
+    code_result = _detect_code(stripped)
+    if code_result["is_code"]:
+        return FormatInfo(
+            format=ContentFormat.CODE,
+            confidence=code_result["confidence"],
+            language=code_result["language"],
+            metadata={"language_scores": code_result["scores"]},
+        )
+
+    # Check for markdown
+    md_score = _score_markdown(stripped)
+    if md_score >= 0.5:
+        return FormatInfo(
+            format=ContentFormat.MARKDOWN,
+            confidence=md_score,
+            metadata={"markdown_score": md_score},
+        )
+
+    # Default to plain text
+    # If we have some markdown patterns but low confidence, still might be markdown
+    if md_score > 0.2:
+        return FormatInfo(
+            format=ContentFormat.MARKDOWN,
+            confidence=md_score,
+            metadata={"markdown_score": md_score, "low_confidence": True},
+        )
+
+    return FormatInfo(format=ContentFormat.PLAIN_TEXT, confidence=0.8)
+
+
+def _score_html(content: str) -> float:
+    """Score content for HTML likelihood.
+
+    Args:
+        content: Content to analyze
+
+    Returns:
+        Score from 0.0 to 1.0 indicating HTML likelihood
+    """
+    matches = 0
+    for pattern in HTML_PATTERNS:
+        if pattern.search(content):
+            matches += 1
+
+    # Normalize score based on number of patterns matched
+    # Need at least 2-3 patterns for high confidence
+    if matches == 0:
+        return 0.0
+    if matches == 1:
+        return 0.3
+    if matches == 2:
+        return 0.6
+    if matches == 3:
+        return 0.8
+
+    return min(1.0, 0.8 + (matches - 3) * 0.05)
+
+
+def _score_markdown(content: str) -> float:
+    """Score content for Markdown likelihood.
+
+    Args:
+        content: Content to analyze
+
+    Returns:
+        Score from 0.0 to 1.0 indicating Markdown likelihood
+    """
+    matches = 0
+    for pattern in MARKDOWN_PATTERNS:
+        if pattern.search(content):
+            matches += 1
+
+    # Normalize score
+    if matches == 0:
+        return 0.0
+    if matches == 1:
+        return 0.3
+    if matches == 2:
+        return 0.5
+    if matches == 3:
+        return 0.7
+
+    return min(1.0, 0.7 + (matches - 3) * 0.05)
+
+
+def _detect_code(content: str) -> dict[str, Any]:
+    """Detect if content is code and identify the language.
+
+    Args:
+        content: Content to analyze
+
+    Returns:
+        Dict with 'is_code', 'confidence', 'language', and 'scores'
+    """
+    # Skip short content
+    if len(content) < 20:
+        return {"is_code": False, "confidence": 0.0, "language": None, "scores": {}}
+
+    # Score each language
+    scores: dict[str, int] = {}
+    for lang, patterns in LANGUAGE_PATTERNS.items():
+        lang_score = 0
+        for pattern in patterns:
+            if pattern.search(content):
+                lang_score += 1
+        if lang_score > 0:
+            scores[lang] = lang_score
+
+    # Find best match
+    if not scores:
+        return {"is_code": False, "confidence": 0.0, "language": None, "scores": {}}
+
+    best_lang = max(scores, key=lambda k: scores[k])
+    best_score = scores[best_lang]
+
+    # Need at least 2 pattern matches for confidence
+    if best_score < 2:
+        return {"is_code": False, "confidence": 0.0, "language": None, "scores": scores}
+
+    # Calculate confidence based on number of matches
+    num_patterns = len(LANGUAGE_PATTERNS.get(best_lang, []))
+    confidence = min(0.95, best_score / max(num_patterns, 1) * 0.8 + 0.3)
+
+    return {
+        "is_code": True,
+        "confidence": confidence,
+        "language": best_lang,
+        "scores": scores,
+    }
+
+
+@dataclass
+class ProcessedPrompt:
+    """Result of full prompt processing pipeline.
+
+    Attributes:
+        markdown: The final processed markdown content
+        original_format: The detected format of the original content
+        detected_language: Programming language if content was code
+        confidence: Detection confidence
+        was_converted: Whether format conversion was applied
+        was_sanitized: Whether sanitization was applied
+        warnings: List of warning messages
+        changes: List of changes made to the content
+        secrets_found: List of detected secrets
+        blocked: Whether content was blocked from storage
+        block_reason: Reason for blocking if blocked=True
+    """
+
+    markdown: str
+    original_format: ContentFormat
+    detected_language: str | None = None
+    confidence: float = 1.0
+    was_converted: bool = False
+    was_sanitized: bool = False
+    warnings: list[str] = field(default_factory=list)
+    changes: list[str] = field(default_factory=list)
+    secrets_found: list[Any] = field(default_factory=list)  # List[SecretMatch]
+    blocked: bool = False
+    block_reason: str | None = None