vbagent 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

vbagent/cli/common.py

@@ -684,16 +684,19 @@ def find_image_for_problem(
     tex_file: Path,
     images_dir: Optional[str | Path] = None,
     extensions: tuple[str, ...] = (".png", ".jpg", ".jpeg", ".webp", ".gif"),
+    auto_discover: bool = True,
 ) -> Optional[Path]:
     """Find the corresponding image file for a tex file.
     
-    Searches for an image with the same base name as the tex file
-    in the specified images directory.
+    Searches for an image with the same base name as the tex file.
+    If images_dir is not provided and auto_discover is True, searches
+    common image locations automatically.
     
     Args:
         tex_file: Path to the .tex file
         images_dir: Directory to search for images (optional)
         extensions: Image file extensions to search for
+        auto_discover: Whether to auto-search common locations if images_dir not provided
         
     Returns:
         Path to the image file if found, None otherwise
@@ -702,39 +705,98 @@ def find_image_for_problem(
         tex_file = Path("src/src_tex/problem_1.tex")
         images_dir = "src/src_images"
         # Will look for: src/src_images/problem_1.png, problem_1.jpg, etc.
+        
+        # Auto-discovery (when images_dir is None):
+        tex_file = Path("agentic/scans/Problem_12.tex")
+        # Will search: images/, ../images/, agentic/images/, etc.
     """
-    if images_dir is None:
+    base_name = tex_file.stem
+    
+    def _search_in_dir(search_dir: Path) -> Optional[Path]:
+        """Search for image in a specific directory."""
+        if not search_dir.exists():
+            return None
+        
+        for ext in extensions:
+            image_path = search_dir / f"{base_name}{ext}"
+            if image_path.exists():
+                return image_path
+            
+            # Also try case-insensitive match
+            image_path_upper = search_dir / f"{base_name}{ext.upper()}"
+            if image_path_upper.exists():
+                return image_path_upper
+        
+        # Try glob pattern for case-insensitive search
+        for ext in extensions:
+            pattern = f"{base_name}.*"
+            matches = list(search_dir.glob(pattern))
+            for match in matches:
+                if match.suffix.lower() in extensions:
+                    return match
+        
         return None
     
-    images_path = Path(images_dir)
-    if not images_path.exists():
+    # If images_dir is explicitly provided, search only there
+    if images_dir is not None:
+        images_path = Path(images_dir)
+        return _search_in_dir(images_path)
+    
+    # Auto-discovery mode
+    if not auto_discover:
         return None
     
-    # Get the base name without extension
-    base_name = tex_file.stem
+    tex_dir = tex_file.parent
+    
+    # Common image directory locations to search (in priority order)
+    search_locations = [
+        # Same directory as tex file
+        tex_dir,
+        # images/ sibling directory
+        tex_dir.parent / "images",
+        # images/ subdirectory
+        tex_dir / "images",
+        # Parent's parent images/ (for nested structures like agentic/scans/)
+        tex_dir.parent.parent / "images",
+        # src_images pattern (common in some projects)
+        tex_dir.parent / "src_images",
+    ]
     
-    # Search for image with matching name
-    for ext in extensions:
-        image_path = images_path / f"{base_name}{ext}"
-        if image_path.exists():
-            return image_path
-        
-        # Also try case-insensitive match
-        image_path_upper = images_path / f"{base_name}{ext.upper()}"
-        if image_path_upper.exists():
-            return image_path_upper
-    
-    # Try glob pattern for case-insensitive search
-    for ext in extensions:
-        pattern = f"{base_name}.*"
-        matches = list(images_path.glob(pattern))
-        for match in matches:
-            if match.suffix.lower() in extensions:
-                return match
+    # Also check for pattern-based sibling directories
+    # e.g., src_tex -> src_images, scans -> images
+    dir_name = tex_dir.name
+    if dir_name.endswith("_tex"):
+        search_locations.append(tex_dir.parent / dir_name.replace("_tex", "_images"))
+    if dir_name == "scans":
+        search_locations.append(tex_dir.parent / "images")
+    
+    for search_dir in search_locations:
+        result = _search_in_dir(search_dir)
+        if result:
+            return result
     
     return None
 
 
+def has_diagram_placeholder(content: str) -> bool:
+    """Check if content contains a diagram placeholder that needs an image.
+    
+    Detects patterns like:
+    - \\input{diagram}
+    - % \\input{diagram} (commented placeholder)
+    - \\begin{center}\\input{diagram}\\end{center}
+    
+    Args:
+        content: LaTeX content to check
+        
+    Returns:
+        True if a diagram placeholder is found (including commented ones)
+    """
+    import re
+    # Match both active and commented placeholders
+    return bool(re.search(r'%?\s*\\input\{diagram\}', content))
+
+
 def discover_images_dir(tex_dir: Path) -> Optional[Path]:
     """Auto-discover images directory based on tex directory structure.
     

vbagent/cli/convert.py

@@ -86,7 +86,7 @@ def _format_latex(content: str) -> str:
     return '\n'.join(formatted_lines)
 
 
-VALID_FORMAT_CHOICES = ["mcq_sc", "mcq_mc", "subjective", "integer"]
+VALID_FORMAT_CHOICES = ["mcq_sc", "mcq_mc", "subjective", "integer", "match", "passage"]
 
 
 def parse_tex_content(tex_path: str) -> str:

vbagent/models/__init__.py

@@ -1,38 +1,67 @@
 """Data models for vbagent.
 
 Uses lazy imports to avoid loading pydantic until models are actually needed.
+
+Available models:
+- ClassificationResult: Result from image classification
+- ScanResult: Result from LaTeX extraction
+- IdeaResult: Extracted physics concepts
+- PipelineResult: Full pipeline output
+- ReviewResult, Suggestion, ReviewStats: QA review models
+- VersionStore, StoredSuggestion: Version tracking
+- BatchResult, BatchStats: Batch processing models
 """
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from .classification import ClassificationResult
+    from .classification import ClassificationResult, QuestionType, Difficulty, DiagramType
     from .scan import ScanResult
     from .idea import IdeaResult
     from .pipeline import PipelineResult
     from .review import ReviewIssueType, Suggestion, ReviewResult, ReviewStats
     from .version_store import SuggestionStatus, StoredSuggestion, VersionStore
+    from .batch import BatchDatabase, ImageRecord, ProcessingStatus
+    from .diff import generate_unified_diff, apply_unified_diff, apply_diff, parse_diff
 
 __all__ = [
+    # Classification
     "ClassificationResult",
+    "QuestionType",
+    "Difficulty",
+    "DiagramType",
+    # Scan
     "ScanResult",
+    # Idea
     "IdeaResult",
+    # Pipeline
     "PipelineResult",
+    # Review
     "ReviewIssueType",
     "Suggestion",
     "ReviewResult",
     "ReviewStats",
+    # Version store
     "SuggestionStatus",
     "StoredSuggestion",
     "VersionStore",
+    # Batch
+    "BatchDatabase",
+    "ImageRecord",
+    "ProcessingStatus",
+    # Diff utilities
+    "generate_unified_diff",
+    "apply_unified_diff",
+    "apply_diff",
+    "parse_diff",
 ]
 
 
 def __getattr__(name: str):
     """Lazy import of model classes to speed up CLI startup."""
-    if name == "ClassificationResult":
-        from .classification import ClassificationResult
-        return ClassificationResult
+    if name in ("ClassificationResult", "QuestionType", "Difficulty", "DiagramType"):
+        from . import classification
+        return getattr(classification, name)
     
     if name == "ScanResult":
         from .scan import ScanResult
@@ -54,4 +83,12 @@ def __getattr__(name: str):
         from . import version_store
         return getattr(version_store, name)
     
+    if name in ("BatchDatabase", "ImageRecord", "ProcessingStatus"):
+        from . import batch
+        return getattr(batch, name)
+    
+    if name in ("generate_unified_diff", "apply_unified_diff", "apply_diff", "parse_diff"):
+        from . import diff
+        return getattr(diff, name)
+    
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

vbagent/prompts/__init__.py

@@ -1 +1,120 @@
-"""Prompt modules for vbagent agents."""
+"""Prompt modules for vbagent agents.
+
+Provides prompt templates for all agent types. These can be used
+to customize agent behavior or create custom agents.
+
+Usage:
+    from vbagent.prompts import get_scanner_prompt, get_variant_prompt
+    
+    # Get scanner prompt for MCQ questions
+    prompt = get_scanner_prompt("mcq_sc")
+    
+    # Get variant prompts
+    system, user = get_variant_prompt("numerical")
+    
+    # Access individual prompts
+    from vbagent.prompts import CLASSIFIER_PROMPT, IDEA_PROMPT
+
+Available prompt modules:
+- scanner: LaTeX extraction prompts by question type
+- variants: Problem variant generation prompts
+- classifier: Image classification prompt
+- idea: Concept extraction prompt
+- alternate: Alternate solution prompt
+- reviewer: QA review prompt
+- tikz: TikZ diagram generation prompt
+- solution_checker, grammar_checker, clarity_checker, tikz_checker: QA checker prompts
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .scanner import get_scanner_prompt, SCANNER_PROMPTS
+    from .classifier import SYSTEM_PROMPT as CLASSIFIER_PROMPT
+    from .idea import SYSTEM_PROMPT as IDEA_PROMPT
+    from .alternate import SYSTEM_PROMPT as ALTERNATE_PROMPT
+    from .reviewer import SYSTEM_PROMPT as REVIEWER_PROMPT
+    from .tikz import SYSTEM_PROMPT as TIKZ_PROMPT
+    from .solution_checker import SYSTEM_PROMPT as SOLUTION_CHECKER_PROMPT
+    from .grammar_checker import SYSTEM_PROMPT as GRAMMAR_CHECKER_PROMPT
+    from .clarity_checker import SYSTEM_PROMPT as CLARITY_CHECKER_PROMPT
+    from .tikz_checker import SYSTEM_PROMPT as TIKZ_CHECKER_PROMPT
+
+__all__ = [
+    # Scanner
+    "get_scanner_prompt",
+    "SCANNER_PROMPTS",
+    # Variant
+    "get_variant_prompt",
+    # Individual prompts
+    "CLASSIFIER_PROMPT",
+    "IDEA_PROMPT",
+    "ALTERNATE_PROMPT",
+    "REVIEWER_PROMPT",
+    "TIKZ_PROMPT",
+    "SOLUTION_CHECKER_PROMPT",
+    "GRAMMAR_CHECKER_PROMPT",
+    "CLARITY_CHECKER_PROMPT",
+    "TIKZ_CHECKER_PROMPT",
+]
+
+
+def get_variant_prompt(variant_type: str) -> tuple[str, str]:
+    """Get the system and user prompts for a variant type.
+    
+    Args:
+        variant_type: Type of variant (numerical, context, conceptual, calculus)
+        
+    Returns:
+        Tuple of (system_prompt, user_template)
+        
+    Raises:
+        ValueError: If variant_type is not valid
+    """
+    from vbagent.agents.variant import get_variant_prompt as _get_variant_prompt
+    return _get_variant_prompt(variant_type)
+
+
+def __getattr__(name: str):
+    """Lazy import of prompt modules."""
+    if name in ("get_scanner_prompt", "SCANNER_PROMPTS"):
+        from . import scanner
+        return getattr(scanner, name)
+    
+    if name == "CLASSIFIER_PROMPT":
+        from .classifier import SYSTEM_PROMPT
+        return SYSTEM_PROMPT
+    
+    if name == "IDEA_PROMPT":
+        from .idea import SYSTEM_PROMPT
+        return SYSTEM_PROMPT
+    
+    if name == "ALTERNATE_PROMPT":
+        from .alternate import SYSTEM_PROMPT
+        return SYSTEM_PROMPT
+    
+    if name == "REVIEWER_PROMPT":
+        from .reviewer import SYSTEM_PROMPT
+        return SYSTEM_PROMPT
+    
+    if name == "TIKZ_PROMPT":
+        from .tikz import SYSTEM_PROMPT
+        return SYSTEM_PROMPT
+    
+    if name == "SOLUTION_CHECKER_PROMPT":
+        from .solution_checker import SYSTEM_PROMPT
+        return SYSTEM_PROMPT
+    
+    if name == "GRAMMAR_CHECKER_PROMPT":
+        from .grammar_checker import SYSTEM_PROMPT
+        return SYSTEM_PROMPT
+    
+    if name == "CLARITY_CHECKER_PROMPT":
+        from .clarity_checker import SYSTEM_PROMPT
+        return SYSTEM_PROMPT
+    
+    if name == "TIKZ_CHECKER_PROMPT":
+        from .tikz_checker import SYSTEM_PROMPT
+        return SYSTEM_PROMPT
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")