Safe Moltbot v2.0 - brain only, no file access

app.py

@@ -1,57 +1,177 @@
+"""
+Moltbot Hybrid Engine - SAFE DEPLOYMENT
+Brain only - NO file access, NO local filesystem access
+Runs on Hugging Face Spaces in isolated container
+"""
 import os
+import re
 import json
-from fastapi import FastAPI, UploadFile, File, HTTPException, Header
+from fastapi import FastAPI, HTTPException, Header
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
 
-# 1. Initialize the App FIRST (Critical Fix)
-app = FastAPI(title="Moltbot Hybrid Engine")
+# Initialize App
+app = FastAPI(
+    title="Moltbot Hybrid Engine",
+    description="Safe AI agent for file matching - brain only, no file access",
+    version="2.0.0"
+)
 
-# 2. Set up API Key
+# API Key for authentication
 API_KEY = os.environ.get("MOLTBOT_API_KEY", "default_insecure_key")
 if API_KEY == "default_insecure_key":
-    print("WARNING: MOLTBOT_API_KEY secret not set. Using insecure default key.")
+    print("WARNING: MOLTBOT_API_KEY not set. Using insecure default.")
 
-# 3. Health Check Endpoint (Keep server alive)
-@app.get("/")
-def read_root():
-    return {"Status": "Running", "Message": "Moltbot Engine is Online"}
-
-# 4. Analysis Tool Endpoint
-@app.post("/tools/analyze_report")
-async def analyze_verification_report(
-    report_file: UploadFile = File(...), 
-    x_api_key: str = Header(None)
-):
-    # Validation
-    if not x_api_key or x_api_key != API_KEY:
-        raise HTTPException(status_code=401, detail="Invalid or missing API Key")
+
+# ============================================================
+# DATA MODELS
+# ============================================================
+
+class FileSearchRequest(BaseModel):
+    missing_filename: str
+    available_files: List[str]
+    context: Optional[str] = None
+
+class FileSearchResponse(BaseModel):
+    status: str
+    missing_filename: str
+    suggestions: List[Dict[str, Any]]
+    confidence: float
+    reasoning: str
+
+class AnalysisRequest(BaseModel):
+    report_data: Dict[str, Any]
+
+class AnalysisResponse(BaseModel):
+    status: str
+    critical_issues: int
+    suggestions: List[str]
+
+
+# ============================================================
+# HELPER FUNCTIONS (Pure logic, no file access)
+# ============================================================
+
+def tokenize(text: str) -> set:
+    clean = re.sub(r'[_\-\.\(\)\[\]]', ' ', text.lower())
+    tokens = set(clean.split())
+    junk = {'pdf', 'mp4', 'jpg', 'jpeg', 'png', 'gif', 'doc', 'docx',
+            'the', 'and', 'to', 'of', 'in', 'a', 'for', 'with', 'on'}
+    return tokens - junk
+
+def calculate_match_score(wanted: set, found: set) -> float:
+    if not wanted:
+        return 0.0
+    common = wanted.intersection(found)
+    return len(common) / len(wanted)
+
+def find_best_matches(missing_filename: str, available_files: List[str], max_results: int = 5) -> List[Dict[str, Any]]:
+    wanted_tokens = tokenize(missing_filename)
+    if not wanted_tokens:
+        return []
+    
+    matches = []
+    for filename in available_files:
+        if filename == missing_filename:
+            matches.append({"filename": filename, "score": 1.0, "match_type": "exact"})
+            continue
+        if filename.lower() == missing_filename.lower():
+            matches.append({"filename": filename, "score": 0.99, "match_type": "case_insensitive"})
+            continue
+        found_tokens = tokenize(filename)
+        score = calculate_match_score(wanted_tokens, found_tokens)
+        if score >= 0.5:
+            matches.append({"filename": filename, "score": round(score, 3), "match_type": "token_match"})
     
-    if not report_file.filename.endswith('.json'):
-        raise HTTPException(status_code=400, detail="Invalid file type. Please upload a JSON report.")
+    matches.sort(key=lambda x: x["score"], reverse=True)
+    return matches[:max_results]
 
-    try:
-        content = await report_file.read()
-        data = json.loads(content)
 
-        # Logic: Extract issues
-        missing_files = data.get("missing_total", 0)
-        structure_issues = data.get("page_structure_analysis", {}).get("bundles_with_structure_issues", 0)
-        suggestions = []
+# ============================================================
+# API ENDPOINTS
+# ============================================================
 
-        if missing_files > 0:
-            root_causes = data.get("root_cause_analysis", {}).get("failures_by_root_cause", {})
-            for cause, details in root_causes.items():
-                suggestions.append(f"Found {details.get('count', 0)} files with root cause '{cause}'. Fix: {details.get('fix_suggestion')}")
+@app.get("/")
+def health_check():
+    return {
+        "status": "running",
+        "service": "Moltbot Hybrid Engine",
+        "version": "2.0.0",
+        "mode": "SAFE - Brain only, no file access"
+    }
 
-        if structure_issues > 0:
-            suggestions.append(f"Found {structure_issues} bundles with structure problems.")
+@app.get("/security")
+def security_info():
+    return {
+        "file_access": False,
+        "network_access": "API only",
+        "isolation": "Hugging Face container",
+        "cannot_do": ["Read files", "Write files", "Delete files", "Access filesystem", "Execute commands"]
+    }
 
-        return {
-            "status": "success",
-            "analysis": {
-                "critical_issues": missing_files + structure_issues,
-                "suggestions": suggestions
-            }
-        }
+@app.post("/api/search", response_model=FileSearchResponse)
+async def search_file(request: FileSearchRequest, x_api_key: str = Header(None)):
+    if not x_api_key or x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API Key")
+    
+    if len(request.missing_filename) > 200:
+        return FileSearchResponse(
+            status="error", missing_filename=request.missing_filename[:50] + "...",
+            suggestions=[], confidence=0.0,
+            reasoning="Filename too long - likely concatenated filenames"
+        )
+    
+    matches = find_best_matches(request.missing_filename, request.available_files)
+    confidence = matches[0]["score"] if matches else 0.0
+    
+    if not matches:
+        reasoning = f"No matches found in {len(request.available_files)} files"
+    elif matches[0]["match_type"] == "exact":
+        reasoning = f"Exact match: {matches[0]['filename']}"
+    else:
+        reasoning = f"Token match with {int(confidence * 100)}% similarity"
+    
+    return FileSearchResponse(
+        status="success", missing_filename=request.missing_filename,
+        suggestions=matches, confidence=confidence, reasoning=reasoning
+    )
+
+@app.post("/api/analyze", response_model=AnalysisResponse)
+async def analyze_report(request: AnalysisRequest, x_api_key: str = Header(None)):
+    if not x_api_key or x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API Key")
+    
+    data = request.report_data
+    suggestions = []
+    missing_files = data.get("missing_total", 0)
+    structure_issues = data.get("page_structure_analysis", {}).get("bundles_with_structure_issues", 0)
+    
+    if missing_files > 0:
+        suggestions.append(f"{missing_files} files missing - check paths")
+    if structure_issues > 0:
+        suggestions.append(f"{structure_issues} bundles have structure problems")
+    
+    return AnalysisResponse(
+        status="success", critical_issues=missing_files + structure_issues, suggestions=suggestions
+    )
+
+@app.post("/api/extract_date")
+async def extract_date(filename: str, x_api_key: str = Header(None)):
+    if not x_api_key or x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API Key")
+    
+    patterns = [
+        (r'(\d{4})-(\d{2})-(\d{2})', 'ISO'),
+        (r'(\d{4})_(\d{2})_(\d{2})', 'underscore'),
+        (r'(\d{4})(\d{2})(\d{2})', 'compact'),
+    ]
+    for pattern, fmt in patterns:
+        match = re.search(pattern, filename)
+        if match:
+            year, month, day = match.groups()
+            return {"status": "found", "date": f"{year}-{int(month):02d}-{int(day):02d}"}
+    return {"status": "not_found", "date": None}
 
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to process report: {str(e)}")
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -1,9 +1,4 @@
-fastapi
-uvicorn
-python-multipart
-requests
-jira
-atlassian-python-api
-google-generativeai
-gitpython
-twilio
+# Moltbot Hybrid Engine - Safe Deployment
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.0.0