ostruct-cli 0.8.1__py3-none-any.whl → 0.8.3__py3-none-any.whl

ostruct/cli/file_info.py

@@ -3,12 +3,26 @@
 import hashlib
 import logging
 import os
+from enum import Enum
 from pathlib import Path
 from typing import Any, Optional
 
 from .errors import FileReadError, OstructFileNotFoundError, PathSecurityError
 from .security import SecurityManager
 
+
+class FileRoutingIntent(Enum):
+    """Represents the intended use of a file in the ostruct pipeline.
+
+    This enum helps distinguish between different file routing intentions
+    to provide appropriate warnings and optimizations.
+    """
+
+    TEMPLATE_ONLY = "template_only"  # -ft, --fta, legacy -f, -d
+    CODE_INTERPRETER = "code_interpreter"  # -fc, --fca
+    FILE_SEARCH = "file_search"  # -fs, --fsa
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -35,6 +49,7 @@ class FileInfo:
         encoding: Optional[str] = None,
         hash_value: Optional[str] = None,
         routing_type: Optional[str] = None,
+        routing_intent: Optional[FileRoutingIntent] = None,
     ) -> None:
         """Initialize FileInfo instance.
 
@@ -45,6 +60,7 @@ class FileInfo:
             encoding: Optional cached encoding
             hash_value: Optional cached hash value
             routing_type: How the file was routed (e.g., 'template', 'code-interpreter')
+            routing_intent: The intended use of the file in the pipeline
 
         Raises:
             FileNotFoundError: If the file does not exist
@@ -59,6 +75,7 @@ class FileInfo:
         self.__size: Optional[int] = None
         self.__mtime: Optional[float] = None
         self.routing_type = routing_type
+        self.routing_intent = routing_intent
 
         logger.debug(
             "Creating FileInfo for path: %s, routing_type: %s",
@@ -132,23 +149,6 @@ class FileInfo:
                 f"Permission denied: {os.path.basename(str(path))}"
             ) from e
 
-        # Add warning for large template-only files accessed via .content
-        # Check if routing_type is 'template' or if it's part of a legacy -f/-d mapping
-        # For simplicity now, let's assume if routing_type is None it could be legacy template
-        is_template_routed = (
-            self.routing_type == "template" or self.routing_type is None
-        )
-        if (
-            is_template_routed and self.size and self.size > 100 * 1024
-        ):  # 100KB threshold
-            logger.warning(
-                f"File '{self.path}' ({self.size / 1024:.1f}KB) was routed for template-only access "
-                f"but its .content is being accessed. This will include the entire file content "
-                f"in the prompt sent to the AI. For large files intended for analysis or search, "
-                f"consider using -fc (Code Interpreter) or -fs (File Search) to optimize token usage, "
-                f"cost, and avoid exceeding model context limits."
-            )
-
     @property
     def path(self) -> str:
         """Get the path relative to security manager's base directory.
@@ -258,6 +258,32 @@ class FileInfo:
             FileReadError: If the file cannot be read, wrapping the underlying cause
                          (FileNotFoundError, UnicodeDecodeError, etc)
         """
+        # Add warning for large template-only files accessed via .content
+        # Use intent-based logic with fallback to routing_type for backward compatibility
+        template_only_intents = {FileRoutingIntent.TEMPLATE_ONLY}
+
+        # Determine if this is template-only routing
+        is_template_only = False
+        if self.routing_intent is not None:
+            # Use intent if available (new logic)
+            is_template_only = self.routing_intent in template_only_intents
+        else:
+            # Fallback to old logic for backward compatibility
+            is_template_only = (
+                self.routing_type == "template" or self.routing_type is None
+            )
+
+        if (
+            is_template_only and self.size and self.size > 100 * 1024
+        ):  # 100KB threshold
+            logger.warning(
+                f"File '{self.path}' ({self.size / 1024:.1f}KB) was routed for template-only access "
+                f"but its .content is being accessed. This will include the entire file content "
+                f"in the prompt sent to the AI. For large files intended for analysis or search, "
+                f"consider using -fc (Code Interpreter) or -fs (File Search) to optimize token usage, "
+                f"cost, and avoid exceeding model context limits."
+            )
+
         if self.__content is None:
             try:
                 self._read_file()
@@ -384,6 +410,7 @@ class FileInfo:
         path: str,
         security_manager: SecurityManager,
         routing_type: Optional[str] = None,
+        routing_intent: Optional[FileRoutingIntent] = None,
     ) -> "FileInfo":
         """Create FileInfo instance from path.
 
@@ -391,6 +418,7 @@ class FileInfo:
             path: Path to file
             security_manager: Security manager for path validation
             routing_type: How the file was routed (e.g., 'template', 'code-interpreter')
+            routing_intent: The intended use of the file in the pipeline
 
         Returns:
             FileInfo instance
@@ -399,7 +427,12 @@ class FileInfo:
             FileNotFoundError: If file does not exist
             PathSecurityError: If path is not allowed
         """
-        return cls(path, security_manager, routing_type=routing_type)
+        return cls(
+            path,
+            security_manager,
+            routing_type=routing_type,
+            routing_intent=routing_intent,
+        )
 
     def __str__(self) -> str:
         """String representation showing path."""
@@ -419,8 +452,10 @@ class FileInfo:
 
         Internal methods can modify private attributes, but external access is prevented.
         """
-        # Allow setting routing_type if it's not already set (i.e., during __init__)
-        if name == "routing_type" and not hasattr(self, name):
+        # Allow setting routing_type and routing_intent if they're not already set (i.e., during __init__)
+        if name in ("routing_type", "routing_intent") and not hasattr(
+            self, name
+        ):
             object.__setattr__(self, name, value)
             return
 

ostruct/cli/file_utils.py

@@ -58,7 +58,7 @@ from ostruct.cli.errors import (
     PathSecurityError,
 )
 
-from .file_info import FileInfo
+from .file_info import FileInfo, FileRoutingIntent
 from .file_list import FileInfoList
 from .security import SecurityManager
 from .security.types import SecurityManagerProtocol
@@ -116,6 +116,7 @@ def collect_files_from_pattern(
     pattern: str,
     security_manager: SecurityManager,
     routing_type: Optional[str] = None,
+    routing_intent: Optional["FileRoutingIntent"] = None,
 ) -> List[FileInfo]:
     """Collect files matching a glob pattern or exact file path.
 
@@ -123,6 +124,7 @@ def collect_files_from_pattern(
         pattern: Glob pattern or file path to match
         security_manager: Security manager for path validation
         routing_type: How the file was routed
+        routing_intent: The intended use of the file in the pipeline
 
     Returns:
         List of FileInfo objects for matched files
@@ -134,7 +136,10 @@ def collect_files_from_pattern(
     if os.path.isfile(pattern):
         try:
             file_info = FileInfo.from_path(
-                pattern, security_manager, routing_type=routing_type
+                pattern,
+                security_manager,
+                routing_type=routing_type,
+                routing_intent=routing_intent,
             )
             return [file_info]
         except PathSecurityError:
@@ -154,7 +159,10 @@ def collect_files_from_pattern(
     for path in matched_paths:
         try:
             file_info = FileInfo.from_path(
-                path, security_manager, routing_type=routing_type
+                path,
+                security_manager,
+                routing_type=routing_type,
+                routing_intent=routing_intent,
             )
             files.append(file_info)
         except PathSecurityError:
@@ -172,6 +180,7 @@ def collect_files_from_directory(
     recursive: bool = False,
     allowed_extensions: Optional[List[str]] = None,
     routing_type: Optional[str] = None,
+    routing_intent: Optional[FileRoutingIntent] = None,
     **kwargs: Any,
 ) -> List[FileInfo]:
     """Collect files from a directory.
@@ -182,6 +191,7 @@ def collect_files_from_directory(
         recursive: Whether to process subdirectories
         allowed_extensions: List of allowed file extensions (without dot)
         routing_type: How the file was routed
+        routing_intent: The intended use of the file in the pipeline
         **kwargs: Additional arguments passed to FileInfo.from_path
 
     Returns:
@@ -283,6 +293,7 @@ def collect_files_from_directory(
                         abs_path,
                         security_manager=security_manager,
                         routing_type=routing_type,
+                        routing_intent=routing_intent,
                         **kwargs,
                     )
                     files.append(file_info)
@@ -347,6 +358,7 @@ def collect_files(
     dir_extensions: Optional[List[str]] = None,
     security_manager: Optional[SecurityManager] = None,
     routing_type: Optional[str] = None,
+    routing_intent: Optional[FileRoutingIntent] = None,
     **kwargs: Any,
 ) -> Dict[str, FileInfoList]:
     """Collect files from multiple sources.
@@ -359,6 +371,7 @@ def collect_files(
         dir_extensions: List of file extensions to include in directory processing
         security_manager: Security manager instance
         routing_type: How the files were routed (passed to FileInfo)
+        routing_intent: The intended use of the file in the pipeline
         **kwargs: Additional arguments passed to FileInfo.from_path
 
     Returns:
@@ -411,6 +424,7 @@ def collect_files(
                 str(path),
                 security_manager=security_manager,
                 routing_type=routing_type,
+                routing_intent=routing_intent,
                 **kwargs,
             )
             files[name] = FileInfoList(
@@ -433,6 +447,7 @@ def collect_files(
                     str(pattern),
                     security_manager=security_manager,
                     routing_type=routing_type,
+                    routing_intent=routing_intent,
                     **kwargs,
                 )
             except PathSecurityError as e:
@@ -476,6 +491,7 @@ def collect_files(
                     recursive=dir_recursive,
                     allowed_extensions=dir_extensions,
                     routing_type=routing_type,
+                    routing_intent=routing_intent,
                     **kwargs,
                 )
             except PathSecurityError as e:

ostruct/cli/json_extract.py

@@ -0,0 +1,75 @@
+import json
+import re
+from typing import Tuple
+
+# Regex to match JSON fenced blocks, handling newlines and indentation flexibly
+# Uses non-greedy matching but ensures we get the complete JSON block
+JSON_RE = re.compile(
+    r"```json\s*\n?([\s\S]*?)\n?\s*```", re.DOTALL | re.MULTILINE
+)
+
+
+def split_json_and_text(raw: str) -> Tuple[dict, str]:
+    """
+    Extract JSON from fenced code blocks and return markdown-only text.
+
+    Args:
+        raw: Raw response text containing fenced JSON and markdown
+
+    Returns:
+        Tuple of (parsed_json_dict, markdown_text_after_json)
+
+    Raises:
+        ValueError: If no JSON block found or JSON is invalid
+
+    Note:
+        Returns first JSON block if multiple exist. Markdown text is everything
+        after the JSON block for downstream annotation processing.
+
+    Example:
+        >>> content = '''```json
+        ... {"result": "success"}
+        ... ```
+        ...
+        ... [Download file.txt](sandbox:/mnt/data/file.txt)'''
+        >>> data, markdown = split_json_and_text(content)
+        >>> data
+        {'result': 'success'}
+        >>> markdown.strip()
+        '[Download file.txt](sandbox:/mnt/data/file.txt)'
+    """
+    # Find the start of the JSON block
+    start_pattern = re.compile(r"```json\s*", re.MULTILINE)
+    start_match = start_pattern.search(raw)
+    if not start_match:
+        raise ValueError("No ```json ... ``` block found")
+
+    # Find the content after the opening ```json
+    content_start = start_match.end()
+
+    # Look for the closing ``` that's not inside a JSON string
+    # We'll try multiple potential end positions and validate the JSON
+    end_pattern = re.compile(r"```", re.MULTILINE)
+
+    for end_match in end_pattern.finditer(raw, content_start):
+        # Extract potential JSON content
+        potential_json = raw[content_start : end_match.start()].strip()
+
+        try:
+            # Try to parse as JSON
+            data = json.loads(potential_json)
+            # If successful, we found the right closing ```
+            markdown_text = raw[end_match.end() :].lstrip()
+            return data, markdown_text
+        except json.JSONDecodeError:
+            # This ``` might be inside a JSON string, continue looking
+            # But if this is the only ``` we found, it's likely invalid JSON
+            continue
+
+    # If we get here, check if we found any closing ``` at all
+    if not list(end_pattern.finditer(raw, content_start)):
+        # No closing ``` found
+        raise ValueError("No ```json ... ``` block found")
+    else:
+        # Found closing ``` but JSON was invalid
+        raise ValueError("Invalid JSON in fenced block")

ostruct/cli/model_creation.py

@@ -197,7 +197,7 @@ def _get_type_with_constraints(
             field_type_cls = Union[tuple(union_types)]
 
         # Apply constraints based on the base type (non-null type)
-        if base_type == str:
+        if base_type is str:
             # Add string-specific constraints to field_kwargs
             if "pattern" in field_schema:
                 field_kwargs["pattern"] = field_schema["pattern"]