codeshield-ai 0.1.0__py3-none-any.whl

codeshield/contextvault/capture.py

@@ -0,0 +1,174 @@
+"""
+ContextVault Capture - Save coding context
+
+Saves your mental state like a game save file:
+- Open files
+- Cursor position
+- Recent changes
+- Timestamps
+"""
+
+import json
+import sqlite3
+from pathlib import Path
+from datetime import datetime
+from dataclasses import dataclass, asdict
+from typing import Optional
+
+
+DB_PATH = Path.home() / ".codeshield" / "context_vault.sqlite"
+
+
+@dataclass
+class CodingContext:
+    """A saved coding context"""
+    name: str
+    created_at: str
+    files: list[str]
+    cursor: Optional[dict] = None
+    notes: Optional[str] = None
+    last_edited_file: Optional[str] = None
+    
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def _ensure_db():
+    """Ensure database exists and has schema"""
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    
+    conn = sqlite3.connect(str(DB_PATH))
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS contexts (
+            name TEXT PRIMARY KEY,
+            created_at TEXT NOT NULL,
+            files TEXT NOT NULL,
+            cursor TEXT,
+            notes TEXT,
+            last_edited_file TEXT
+        )
+    """)
+    
+    conn.commit()
+    conn.close()
+
+
+def save_context(
+    name: str,
+    files: list[str] = None,
+    cursor: dict = None,
+    notes: str = None,
+    last_edited_file: str = None,
+) -> dict:
+    """
+    Save coding context.
+    
+    Args:
+        name: Unique name for this context
+        files: List of open file paths
+        cursor: Cursor position {file, line, column}
+        notes: Optional notes about current work
+        last_edited_file: Last file that was edited
+    
+    Returns:
+        Dict with save confirmation
+    """
+    _ensure_db()
+    
+    context = CodingContext(
+        name=name,
+        created_at=datetime.now().isoformat(),
+        files=files or [],
+        cursor=cursor,
+        notes=notes,
+        last_edited_file=last_edited_file,
+    )
+    
+    conn = sqlite3.connect(str(DB_PATH))
+    cursor_db = conn.cursor()
+    
+    cursor_db.execute("""
+        INSERT OR REPLACE INTO contexts 
+        (name, created_at, files, cursor, notes, last_edited_file)
+        VALUES (?, ?, ?, ?, ?, ?)
+    """, (
+        context.name,
+        context.created_at,
+        json.dumps(context.files),
+        json.dumps(context.cursor) if context.cursor else None,
+        context.notes,
+        context.last_edited_file,
+    ))
+    
+    conn.commit()
+    conn.close()
+    
+    return {
+        "success": True,
+        "message": f"Context '{name}' saved at {context.created_at}",
+        "context": context.to_dict(),
+    }
+
+
+def list_contexts() -> list[dict]:
+    """List all saved contexts"""
+    _ensure_db()
+    
+    conn = sqlite3.connect(str(DB_PATH))
+    cursor = conn.cursor()
+    
+    cursor.execute("SELECT name, created_at, notes FROM contexts ORDER BY created_at DESC")
+    rows = cursor.fetchall()
+    
+    conn.close()
+    
+    return [
+        {"name": row[0], "created_at": row[1], "notes": row[2]}
+        for row in rows
+    ]
+
+
+def get_context(name: str) -> Optional[CodingContext]:
+    """Get a specific context by name"""
+    _ensure_db()
+    
+    conn = sqlite3.connect(str(DB_PATH))
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        SELECT name, created_at, files, cursor, notes, last_edited_file
+        FROM contexts WHERE name = ?
+    """, (name,))
+    
+    row = cursor.fetchone()
+    conn.close()
+    
+    if not row:
+        return None
+    
+    return CodingContext(
+        name=row[0],
+        created_at=row[1],
+        files=json.loads(row[2]),
+        cursor=json.loads(row[3]) if row[3] else None,
+        notes=row[4],
+        last_edited_file=row[5],
+    )
+
+
+def delete_context(name: str) -> bool:
+    """Delete a context by name"""
+    _ensure_db()
+    
+    conn = sqlite3.connect(str(DB_PATH))
+    cursor = conn.cursor()
+    
+    cursor.execute("DELETE FROM contexts WHERE name = ?", (name,))
+    deleted = cursor.rowcount > 0
+    
+    conn.commit()
+    conn.close()
+    
+    return deleted

codeshield/contextvault/restore.py

@@ -0,0 +1,115 @@
+"""
+ContextVault Restore - Restore coding context
+
+Restores your mental state with AI briefing:
+- Reopens files
+- Returns AI summary of where you left off
+"""
+
+from typing import Optional
+from datetime import datetime
+
+from codeshield.contextvault.capture import get_context, CodingContext
+
+
+def restore_context(name: str) -> dict:
+    """
+    Restore a previously saved coding context.
+    
+    Args:
+        name: Name of context to restore
+    
+    Returns:
+        Dict with context info and AI briefing
+    """
+    context = get_context(name)
+    
+    if not context:
+        return {
+            "success": False,
+            "error": f"Context '{name}' not found",
+            "available_contexts": [],  # Could list available ones
+        }
+    
+    # Generate AI briefing
+    briefing = generate_briefing(context)
+    
+    return {
+        "success": True,
+        "context": context.to_dict(),
+        "briefing": briefing,
+        "files_to_open": context.files,
+        "cursor_position": context.cursor,
+    }
+
+
+def generate_briefing(context: CodingContext) -> str:
+    """
+    Generate a natural language briefing about the context.
+    
+    Uses LLM if available, otherwise generates basic briefing.
+    """
+    # Calculate time since context was saved
+    try:
+        saved_time = datetime.fromisoformat(context.created_at)
+        time_diff = datetime.now() - saved_time
+        
+        if time_diff.days > 0:
+            time_str = f"{time_diff.days} days ago"
+        elif time_diff.seconds > 3600:
+            hours = time_diff.seconds // 3600
+            time_str = f"{hours} hours ago"
+        else:
+            minutes = time_diff.seconds // 60
+            time_str = f"{minutes} minutes ago"
+    except:
+        time_str = "unknown time ago"
+    
+    # Try to use LLM for briefing
+    try:
+        from codeshield.utils.llm import get_llm_client
+        
+        client = get_llm_client()
+        llm_briefing = client.generate_context_briefing({
+            "files": context.files,
+            "last_edited": context.last_edited_file,
+            "cursor": context.cursor,
+            "notes": context.notes,
+            "time_ago": time_str,
+        })
+        
+        if llm_briefing:
+            return llm_briefing
+    except:
+        pass
+    
+    # Fallback to basic briefing
+    briefing_parts = []
+    
+    if context.files:
+        file_count = len(context.files)
+        last_file = context.files[-1].split('/')[-1].split('\\')[-1] if context.files else "unknown"
+        briefing_parts.append(f"You had {file_count} files open. Last working on '{last_file}'.")
+    
+    if context.cursor:
+        line = context.cursor.get('line', '?')
+        briefing_parts.append(f"Cursor was at line {line}.")
+    
+    if context.notes:
+        briefing_parts.append(f"Your notes: {context.notes}")
+    
+    briefing_parts.append(f"This was saved {time_str}.")
+    
+    return " ".join(briefing_parts)
+
+
+def quick_restore() -> Optional[dict]:
+    """Quick restore the most recent context"""
+    from codeshield.contextvault.capture import list_contexts
+    
+    contexts = list_contexts()
+    if not contexts:
+        return None
+    
+    most_recent = contexts[0]["name"]
+    return restore_context(most_recent)

codeshield/mcp/__init__.py

@@ -0,0 +1 @@
+"""MCP Server module"""

codeshield/mcp/hooks.py

@@ -0,0 +1,65 @@
+"""
+Code Interception Hooks
+
+This module provides hooks that can be integrated into:
+1. Pre-commit hooks (Git)
+2. CI/CD pipelines
+3. IDE save actions (if supported)
+
+It serves as the entry point for automated code verification.
+"""
+
+import sys
+import os
+from pathlib import Path
+from codeshield.trustgate.checker import verify_code, verify_file
+
+def pre_commit_hook(files: list[str]) -> bool:
+    """
+    Git pre-commit hook: Verify all changed files.
+    Returns True if verification passes, False otherwise.
+    """
+    print("🛡️ CodeShield Verification Hook Running...")
+    
+    all_passed = True
+    
+    for file_path in files:
+        if not file_path.endswith('.py'):
+            continue
+            
+        print(f"Checking {file_path}...")
+        
+        # Verify file
+        try:
+            result = verify_file(file_path)
+            
+            if not result.is_valid:
+                all_passed = False
+                print(f"❌ Issues in {file_path}:")
+                for issue in result.issues:
+                    print(f"  [{issue.severity}] {issue.message}")
+            else:
+                print(f"✅ {file_path} passed ({result.confidence_score:.0%} confidence)")
+                
+        except Exception as e:
+            print(f"⚠️ Error checking {file_path}: {e}")
+            all_passed = False
+            
+    return all_passed
+
+def code_interceptor(code: str, source: str = "unknown") -> dict:
+    """
+    General purpose interceptor for any code snippet.
+    Useful for IDE plugins or content scripts to verify code on the fly.
+    """
+    result = verify_code(code)
+    return result.to_dict()
+
+if __name__ == "__main__":
+    # Example CLI usage: python -m codeshield.mcp.hooks file1.py file2.py
+    if len(sys.argv) > 1:
+        files = sys.argv[1:]
+        success = pre_commit_hook(files)
+        sys.exit(0 if success else 1)
+    else:
+        print("Usage: python -m codeshield.mcp.hooks <file1> <file2> ...")

codeshield/mcp/server.py

@@ -0,0 +1,319 @@
+"""
+MCP Server - Proper FastMCP implementation with LeanMCP Observability
+
+Uses the official MCP Python SDK (FastMCP) to expose CodeShield tools
+as a proper MCP server that integrates with Claude, Cursor, etc.
+
+Integrations:
+- FastMCP: MCP protocol implementation
+- LeanMCP: Observability, metrics, and analytics tracking
+- CometAPI/Novita/AIML: LLM providers for code fixes
+"""
+
+from typing import Optional, Any
+import json
+import time
+
+# Try to import FastMCP, fallback to simple HTTP if not available
+try:
+    from mcp.server.fastmcp import FastMCP
+    HAS_FASTMCP = True
+except ImportError:
+    HAS_FASTMCP = False
+    FastMCP = None
+
+
+def create_mcp_server():
+    """Create and configure the CodeShield MCP server with LeanMCP observability"""
+    
+    if not HAS_FASTMCP:
+        raise ImportError(
+            "MCP SDK not installed. Run: pip install mcp"
+        )
+    
+    # Initialize LeanMCP tracking
+    from codeshield.utils.leanmcp import get_leanmcp_client
+    leanmcp = get_leanmcp_client()
+    
+    # Create FastMCP server
+    mcp = FastMCP("CodeShield")
+    
+    # ============================================
+    # TOOL: verify_code
+    # ============================================
+    @mcp.tool()
+    def verify_code(code: str, auto_fix: bool = True) -> dict:
+        """
+        Verify Python code for syntax errors, missing imports, and other issues.
+        Returns verification report with confidence score and optional auto-fixes.
+        
+        Args:
+            code: Python code to verify
+            auto_fix: Whether to automatically fix issues (default: True)
+        
+        Returns:
+            Verification report with issues, fixes, and confidence score
+        """
+        start_time = time.time()
+        try:
+            from codeshield.trustgate.checker import verify_code as _verify
+            
+            result = _verify(code, auto_fix=auto_fix)
+            duration_ms = int((time.time() - start_time) * 1000)
+            leanmcp.track_tool_call("verify_code", duration_ms=duration_ms, success=True)
+            return result.to_dict()
+        except Exception as e:
+            duration_ms = int((time.time() - start_time) * 1000)
+            leanmcp.track_tool_call("verify_code", duration_ms=duration_ms, success=False, error_message=str(e))
+            raise
+    
+    # ============================================
+    # TOOL: full_verify (with sandbox execution)
+    # ============================================
+    @mcp.tool()
+    def full_verify(code: str) -> dict:
+        """
+        Complete verification: syntax + imports + sandbox execution.
+        Runs code in secure sandbox (Daytona) to confirm it actually works.
+        
+        Args:
+            code: Python code to verify
+        
+        Returns:
+            Comprehensive verification report including execution results
+        """
+        start_time = time.time()
+        try:
+            from codeshield.trustgate.sandbox import full_verification
+            
+            result = full_verification(code)
+            duration_ms = int((time.time() - start_time) * 1000)
+            leanmcp.track_tool_call("full_verify", duration_ms=duration_ms, success=True)
+            return result
+        except Exception as e:
+            duration_ms = int((time.time() - start_time) * 1000)
+            leanmcp.track_tool_call("full_verify", duration_ms=duration_ms, success=False, error_message=str(e))
+            raise
+    
+    # ============================================
+    # TOOL: check_style
+    # ============================================
+    @mcp.tool()
+    def check_style(code: str, codebase_path: str = ".") -> dict:
+        """
+        Check code against codebase conventions.
+        Detects naming mismatches and suggests corrections.
+        
+        Args:
+            code: Code to check
+            codebase_path: Path to codebase for convention extraction
+        
+        Returns:
+            Style check results with issues and corrections
+        """
+        start_time = time.time()
+        try:
+            from codeshield.styleforge.corrector import check_style as _check
+            
+            result = _check(code, codebase_path)
+            duration_ms = int((time.time() - start_time) * 1000)
+            leanmcp.track_tool_call("check_style", duration_ms=duration_ms, success=True)
+            return result.to_dict()
+        except Exception as e:
+            duration_ms = int((time.time() - start_time) * 1000)
+            leanmcp.track_tool_call("check_style", duration_ms=duration_ms, success=False, error_message=str(e))
+            raise
+    
+    # ============================================
+    # TOOL: save_context
+    # ============================================
+    @mcp.tool()
+    def save_context(
+        name: str,
+        files: list[str] = None,
+        cursor: dict = None,
+        notes: str = None,
+    ) -> dict:
+        """
+        Save current coding context for later restoration.
+        Like a game save file for your coding session.
+        
+        Args:
+            name: Unique name for this context snapshot
+            files: List of open file paths
+            cursor: Current cursor position {file, line, column}
+            notes: Optional notes about current work
+        
+        Returns:
+            Confirmation of saved context
+        """
+        from codeshield.contextvault.capture import save_context as _save
+        
+        return _save(
+            name=name,
+            files=files or [],
+            cursor=cursor,
+            notes=notes,
+        )
+    
+    # ============================================
+    # TOOL: restore_context
+    # ============================================
+    @mcp.tool()
+    def restore_context(name: str) -> dict:
+        """
+        Restore a previously saved coding context.
+        Returns AI briefing of where you left off.
+        
+        Args:
+            name: Name of context to restore
+        
+        Returns:
+            Context info with AI briefing
+        """
+        from codeshield.contextvault.restore import restore_context as _restore
+        
+        return _restore(name=name)
+    
+    # ============================================
+    # TOOL: list_contexts
+    # ============================================
+    @mcp.tool()
+    def list_contexts() -> list[dict]:
+        """
+        List all saved coding contexts.
+        
+        Returns:
+            List of saved contexts with names and timestamps
+        """
+        from codeshield.contextvault.capture import list_contexts as _list
+        
+        return _list()
+    
+    # ============================================
+    # TOOL: mcp_health (Observability)
+    # ============================================
+    @mcp.tool()
+    def mcp_health() -> dict:
+        """
+        Check MCP server health and connectivity status.
+        Returns status of all integrated services and providers.
+        
+        Use this to verify:
+        - MCP server is running correctly
+        - LLM providers are configured (CometAPI, Novita, AIML)
+        - All CodeShield modules are loaded
+        
+        Returns:
+            Health status with provider configurations and stats
+        """
+        from codeshield.utils.llm import get_llm_client, get_provider_stats
+        
+        # Check LLM providers
+        llm = get_llm_client()
+        provider_status = llm.get_status()
+        provider_stats = get_provider_stats()
+        
+        # Check module availability
+        modules_status = {}
+        try:
+            from codeshield.trustgate import checker
+            modules_status["trustgate"] = "loaded"
+        except ImportError:
+            modules_status["trustgate"] = "not_available"
+        
+        try:
+            from codeshield.styleforge import corrector
+            modules_status["styleforge"] = "loaded"
+        except ImportError:
+            modules_status["styleforge"] = "not_available"
+        
+        try:
+            from codeshield.contextvault import capture
+            modules_status["contextvault"] = "loaded"
+        except ImportError:
+            modules_status["contextvault"] = "not_available"
+        
+        # Get LeanMCP metrics
+        leanmcp_status = leanmcp.get_status()
+        leanmcp_metrics = leanmcp.get_metrics()
+        
+        # Check Daytona configuration
+        import os
+        daytona_configured = bool(os.getenv("DAYTONA_API_KEY"))
+        
+        return {
+            "status": "healthy",
+            "mcp_server": "CodeShield",
+            "version": "1.0.0",
+            "integrations": {
+                "leanmcp": leanmcp_status,
+                "daytona": {
+                    "configured": daytona_configured,
+                    "api_url": os.getenv("DAYTONA_API_URL", "https://app.daytona.io/api")
+                }
+            },
+            "llm_providers": provider_status,
+            "llm_stats": provider_stats,
+            "mcp_metrics": leanmcp_metrics,
+            "modules": modules_status,
+            "message": "MCP server is running with LeanMCP observability."
+        }
+    
+    # ============================================
+    # TOOL: test_llm_connection
+    # ============================================
+    @mcp.tool()
+    def test_llm_connection(provider: str = None) -> dict:
+        """
+        Test LLM provider connectivity with a simple request.
+        
+        Args:
+            provider: Optional specific provider to test (cometapi, novita, aiml)
+                     If not specified, tests the first available provider.
+        
+        Returns:
+            Connection test result with provider used and response time
+        """
+        import time
+        from codeshield.utils.llm import get_llm_client
+        
+        llm = get_llm_client()
+        if provider:
+            llm.preferred_provider = provider
+        
+        start_time = time.time()
+        response = llm.chat(
+            prompt="Reply with exactly: 'CodeShield MCP connected'",
+            max_tokens=20
+        )
+        elapsed = time.time() - start_time
+        
+        if response:
+            return {
+                "success": True,
+                "provider": response.provider,
+                "model": response.model,
+                "response": response.content,
+                "response_time_ms": round(elapsed * 1000),
+                "tokens_used": response.tokens_used
+            }
+        else:
+            return {
+                "success": False,
+                "error": "No LLM provider available or all providers failed",
+                "hint": "Check that at least one of COMETAPI_KEY, NOVITA_API_KEY, or AIML_API_KEY is set"
+            }
+    
+    return mcp
+
+
+def run_mcp_server():
+    """Run the MCP server using stdio transport"""
+    mcp = create_mcp_server()
+    mcp.run()
+
+
+# For direct execution
+if __name__ == "__main__":
+    run_mcp_server()

codeshield/styleforge/__init__.py

@@ -0,0 +1 @@
+"""StyleForge - Convention enforcement module"""