roma-debug 0.1.0__py3-none-any.whl

roma_debug/prompts.py

@@ -0,0 +1,153 @@
+"""System prompts for ROMA Debug."""
+
+SYSTEM_PROMPT = """You are a code repair engine. Analyze the error and context provided.
+
+CRITICAL RULES:
+1. Return ONLY valid JSON. No markdown. No explanations outside JSON.
+2. The "full_code_block" must contain the COMPLETE corrected code for the function, class, or file segment.
+3. Do not include line numbers or markers (like ">>") in the code.
+4. Preserve all imports and dependencies that were in the original context.
+
+OUTPUT FORMAT (strict JSON):
+{
+  "filepath": "path/to/file.py",
+  "full_code_block": "def fixed_function():\\n    # complete corrected code here\\n    pass",
+  "explanation": "Brief explanation of what was fixed and why."
+}
+
+FILEPATH RULES:
+- Extract the filepath from the traceback (e.g., File "/app/src/main.py", line 10).
+- If the error is a GENERAL SYSTEM ERROR (API errors, network errors, configuration issues, authentication failures, etc.) where no specific source file is mentioned, set "filepath" to null.
+- If the error log does not contain a clear file path, set "filepath" to null.
+- DO NOT INVENT or GUESS file paths. Only use paths explicitly shown in the error traceback.
+- When filepath is null, provide general advice in the explanation and example fix code in full_code_block.
+
+Examples of when filepath should be null:
+- "400 API key not valid" (configuration error)
+- "Connection refused" (network error)
+- "ModuleNotFoundError: No module named 'xyz'" (environment error)
+- Any error without a File "..." traceback line
+"""
+
+SYSTEM_PROMPT_SIMPLE = """You are a code correction engine. Do not explain the plan. Do not ask for clarification. Receive error -> Output Code Fix only."""
+
+
+# V2 System Prompt for Deep Debugging
+SYSTEM_PROMPT_V2 = """You are a code repair engine with deep project understanding and multi-language support.
+
+You analyze errors across Python, JavaScript, TypeScript, Go, Rust, Java, and other languages.
+You receive comprehensive context including:
+- PROJECT INFORMATION: Project type, frameworks, and entry points
+- ERROR ANALYSIS: Analyzed error type, category, and relevant files
+- PRIMARY ERROR LOCATION: The file/function where the error occurred or relevant files
+- TRACEBACK/STACK TRACE: Full call stack showing execution flow (when available)
+- UPSTREAM CONTEXT: Code from imported modules that may be relevant
+- KEY PROJECT FILES: Entry point code for context
+
+Your task is to:
+1. Identify the root cause of the error (which may be in a different file than where the error surfaced)
+2. Provide a complete fix for the code
+3. Explain the fix and any root cause if it's in a different file
+
+CRITICAL RULES:
+1. Return ONLY valid JSON. No markdown. No explanations outside JSON.
+2. The "full_code_block" must contain the COMPLETE corrected code for the entire file or function.
+3. Do not include line numbers or markers (like ">>") in the code.
+4. Preserve all imports and dependencies from the original context.
+5. Match the code style and conventions of the existing codebase.
+6. Be language-aware: use appropriate syntax for the detected language.
+
+OUTPUT FORMAT (strict JSON):
+{
+  "filepath": "path/to/file.ext",
+  "full_code_block": "complete corrected code here",
+  "explanation": "What was fixed and why",
+  "root_cause_file": "path/to/different/file.ext",
+  "root_cause_explanation": "If the bug originates in a different file, explain here",
+  "additional_fixes": [
+    {
+      "filepath": "path/to/another/file.ext",
+      "full_code_block": "additional fix code",
+      "explanation": "Why this file also needs changes"
+    }
+  ]
+}
+
+FILEPATH RULES (IMPORTANT):
+- Use the exact filepath from the traceback when available.
+- When PROJECT INFORMATION and RELEVANT FILES are provided, USE those file paths for the fix.
+- If ERROR ANALYSIS identifies relevant files (e.g., "Relevant Files: app.py"), USE those paths.
+- If you see "Entry Points: app.py" or similar, and the error relates to that file, USE that path.
+- If the error originates from imported code, set "root_cause_file" to that path.
+- ONLY set "filepath" to null if:
+  - The error is purely a configuration/environment issue (API keys, missing packages)
+  - No project files are provided in the context
+  - The error cannot be fixed by modifying any source code
+
+ROOT CAUSE ANALYSIS:
+When analyzing errors, consider:
+- Is the error caused by bad data passed from another module?
+- Is there a type mismatch from an upstream function?
+- Are there missing validations in calling code?
+- Is the error in the code itself, or in how it's being called?
+
+If the root cause is in a DIFFERENT file than where the error occurred:
+- Set "filepath" to the file that needs the primary fix
+- Set "root_cause_file" to where the issue originates
+- Provide fixes for both if needed via "additional_fixes"
+
+COMMON ERROR PATTERNS:
+- "Cannot GET /path" -> Usually needs route handler added to web server (app.py, server.js, etc.)
+- "404 Not Found" -> Missing route or static file configuration
+- "TypeError: Cannot read property" -> Null/undefined handling issue
+- "AttributeError" -> Object doesn't have expected attribute
+
+LANGUAGE-SPECIFIC NOTES:
+- Python/Flask: For static file errors, check static_folder config and add serve routes
+- JavaScript/Express: For routing errors, check app.use() and route handlers
+- Go: Watch for nil pointers, error handling, and goroutine issues
+- Rust: Watch for ownership, borrowing, and Option/Result handling
+
+Examples of when filepath should be null:
+- "400 API key not valid" (configuration error - no code fix)
+- "Connection refused to external service" (network error - no code fix)
+- Pure environment setup issues with no project context provided
+
+IMPORTANT - BE THOROUGH:
+1. READ the source files provided CAREFULLY before responding
+2. UNDERSTAND what the code is doing and what it's trying to achieve
+3. IDENTIFY the actual root cause - don't assume "no changes needed"
+4. If a file is missing (like index.html), the FIX might be to:
+   - Add code to serve from a different location
+   - Add code to generate the missing file
+   - Change the static file configuration
+5. ALWAYS provide a working fix when source code is provided
+6. The "full_code_block" should be the COMPLETE file content ready to save
+
+NEVER respond with "no code changes needed" if source files are provided.
+There is ALWAYS a code fix when the user provides an error with source context.
+"""
+
+
+# Prompt for explaining errors without fixing
+SYSTEM_PROMPT_EXPLAIN = """You are a debugging assistant. Analyze the error and context to explain what went wrong.
+
+OUTPUT FORMAT (strict JSON):
+{
+  "error_type": "The type/category of error",
+  "error_summary": "One sentence summary of the error",
+  "root_cause": "Detailed explanation of why this error occurred",
+  "call_chain_analysis": "Analysis of how the execution flow led to this error",
+  "suggested_fixes": [
+    "First suggested approach to fix",
+    "Alternative approach if applicable"
+  ],
+  "related_files": ["file1.py", "file2.py"]
+}
+
+Focus on:
+1. Understanding the full call chain
+2. Identifying where data flows incorrectly
+3. Explaining the root cause clearly
+4. Suggesting practical fixes
+"""

roma_debug/server.py

@@ -0,0 +1,247 @@
+"""FastAPI Backend for ROMA Debug.
+
+Provides V1 and V2 API endpoints for code debugging.
+"""
+
+import logging
+import os
+from typing import Optional, List
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from roma_debug import __version__
+from roma_debug.config import GEMINI_API_KEY, get_api_key_status
+from roma_debug.core.engine import analyze_error, analyze_error_v2
+from roma_debug.core.models import Language
+
+logger = logging.getLogger("uvicorn.error")
+
+
+app = FastAPI(
+    title="ROMA Debug API",
+    description="Code debugging API powered by Gemini. Supports multi-language debugging with V2 deep analysis.",
+    version=__version__,
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# V1 Models
+class AnalyzeRequest(BaseModel):
+    """Request schema for /analyze endpoint."""
+    log: str
+    context: str = ""
+
+
+class AnalyzeResponse(BaseModel):
+    """Response schema for /analyze endpoint."""
+    explanation: str
+    code: str
+    filepath: Optional[str] = None
+
+
+# V2 Models
+class AdditionalFixResponse(BaseModel):
+    """An additional fix for another file."""
+    filepath: str
+    code: str
+    explanation: str
+
+
+class AnalyzeRequestV2(BaseModel):
+    """Request schema for /analyze/v2 endpoint."""
+    log: str
+    context: str = ""
+    project_root: Optional[str] = None
+    language: Optional[str] = None
+    include_upstream: bool = True
+
+
+class AnalyzeResponseV2(BaseModel):
+    """Response schema for /analyze/v2 endpoint."""
+    explanation: str
+    code: str
+    filepath: Optional[str] = None
+    root_cause_file: Optional[str] = None
+    root_cause_explanation: Optional[str] = None
+    additional_fixes: List[AdditionalFixResponse] = []
+    model_used: str = ""
+
+
+# V1 Endpoints
+@app.post("/analyze", response_model=AnalyzeResponse)
+async def analyze(request: AnalyzeRequest):
+    """Analyze an error log and return a structured code fix.
+
+    Accepts JSON { "log": "...", "context": "..." }
+    Returns structured fix with explanation, code, and filepath.
+
+    Args:
+        request: The analysis request with log and optional context
+
+    Returns:
+        AnalyzeResponse with explanation, code, and optional filepath
+
+    Raises:
+        HTTPException: If analysis fails
+    """
+    try:
+        result = analyze_error(request.log, request.context)
+        return AnalyzeResponse(
+            explanation=result.explanation,
+            code=result.full_code_block,
+            filepath=result.filepath,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
+
+
+# V2 Endpoints
+@app.post("/analyze/v2", response_model=AnalyzeResponseV2)
+async def analyze_v2(request: AnalyzeRequestV2):
+    """Analyze an error with V2 deep debugging.
+
+    V2 provides:
+    - Multi-language support (Python, JavaScript, TypeScript, Go, Rust, Java)
+    - Root cause analysis across multiple files
+    - Import tracing and call chain analysis
+    - Multiple fixes when bugs span files
+
+    Accepts JSON:
+    {
+        "log": "error traceback",
+        "context": "optional pre-extracted context",
+        "project_root": "optional project root path",
+        "language": "optional language hint",
+        "include_upstream": true
+    }
+
+    Returns structured fix with root cause analysis.
+
+    Args:
+        request: V2 analysis request
+
+    Returns:
+        AnalyzeResponseV2 with root cause analysis and multiple fixes
+
+    Raises:
+        HTTPException: If analysis fails
+    """
+    try:
+        # Build context if not provided
+        context = request.context
+        if not context and request.project_root:
+            try:
+                from roma_debug.tracing.context_builder import ContextBuilder
+
+                language_hint = None
+                if request.language:
+                    language_map = {
+                        "python": Language.PYTHON,
+                        "javascript": Language.JAVASCRIPT,
+                        "typescript": Language.TYPESCRIPT,
+                        "go": Language.GO,
+                        "rust": Language.RUST,
+                        "java": Language.JAVA,
+                    }
+                    language_hint = language_map.get(request.language.lower())
+
+                builder = ContextBuilder(project_root=request.project_root)
+                analysis_ctx = builder.build_analysis_context(
+                    request.log,
+                    language_hint=language_hint,
+                )
+                context = builder.get_context_for_prompt(
+                    analysis_ctx,
+                    include_upstream=request.include_upstream,
+                )
+            except Exception as e:
+                logger.warning(f"Context building failed, using basic context: {e}")
+
+        result = analyze_error_v2(
+            request.log,
+            context,
+            include_upstream=request.include_upstream,
+        )
+
+        return AnalyzeResponseV2(
+            explanation=result.explanation,
+            code=result.full_code_block,
+            filepath=result.filepath,
+            root_cause_file=result.root_cause_file,
+            root_cause_explanation=result.root_cause_explanation,
+            additional_fixes=[
+                AdditionalFixResponse(
+                    filepath=fix.filepath,
+                    code=fix.full_code_block,
+                    explanation=fix.explanation,
+                )
+                for fix in result.additional_fixes
+            ],
+            model_used=result.model_used,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.exception("V2 analysis failed")
+        raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    return {
+        "status": "ok",
+        "version": __version__,
+        "api_key_configured": bool(GEMINI_API_KEY),
+    }
+
+
+@app.get("/info")
+async def info():
+    """Get API information and capabilities."""
+    from roma_debug.parsers.treesitter_parser import TreeSitterParser
+
+    supported_languages = []
+    try:
+        supported_languages = [lang.value for lang in TreeSitterParser.supported_languages()]
+    except Exception:
+        supported_languages = ["python"]  # Fallback
+
+    return {
+        "version": __version__,
+        "api_version": "v2",
+        "capabilities": {
+            "multi_language": True,
+            "deep_debugging": True,
+            "root_cause_analysis": True,
+            "multiple_fixes": True,
+        },
+        "supported_languages": supported_languages + ["python"],  # Python always supported via AST
+        "endpoints": {
+            "v1": "/analyze",
+            "v2": "/analyze/v2",
+            "health": "/health",
+            "info": "/info",
+        },
+    }
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Log startup info."""
+    status = get_api_key_status()
+    logger.info(f"Server started. Gemini API Key status: [{status}]")
+    logger.info(f"ROMA Debug API v{__version__} ready")
+    logger.info("Endpoints: /analyze (V1), /analyze/v2 (V2 with deep debugging)")

roma_debug/tracing/__init__.py

@@ -0,0 +1,28 @@
+"""ROMA Debug Tracing - Import resolution, dependency analysis, and project awareness.
+
+This package provides tools for:
+- Tracing imports and building dependency graphs
+- Scanning and understanding project structure
+- Analyzing errors to find relevant files
+- Deep debugging across files
+"""
+
+from roma_debug.tracing.import_resolver import ImportResolver, resolve_import
+from roma_debug.tracing.dependency_graph import DependencyGraph
+from roma_debug.tracing.call_chain import CallChainAnalyzer
+from roma_debug.tracing.context_builder import ContextBuilder
+from roma_debug.tracing.project_scanner import ProjectScanner, ProjectInfo, ProjectFile
+from roma_debug.tracing.error_analyzer import ErrorAnalyzer, ErrorAnalysis
+
+__all__ = [
+    "ImportResolver",
+    "resolve_import",
+    "DependencyGraph",
+    "CallChainAnalyzer",
+    "ContextBuilder",
+    "ProjectScanner",
+    "ProjectInfo",
+    "ProjectFile",
+    "ErrorAnalyzer",
+    "ErrorAnalysis",
+]