ostruct-cli 0.8.8__py3-none-any.whl → 1.0.0__py3-none-any.whl

ostruct_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,80 @@
+ostruct/__init__.py,sha256=X6zo6V7ZNMv731Wi388aTVQngD1410ExGwGx4J6lpyo,187
+ostruct/cli/__init__.py,sha256=njg70kPnRja8KqP_y93CIWPyeNj8EzH8AhHotn0jJAc,820
+ostruct/cli/attachment_processor.py,sha256=_RcE8tdJ5ey5jsL5UBsOadKrAqBjr71nLqZsv8b2kwg,16469
+ostruct/cli/attachment_template_bridge.py,sha256=iehtZ3AR1QoQP_fQxiVH_jV4z-3bCsfvRkwoMz8DEWs,35058
+ostruct/cli/base_errors.py,sha256=o-877bJJA8yJWISRPy0KyL6wDu1-_avddmQIfVePuFM,5989
+ostruct/cli/cache_manager.py,sha256=ej3KrRfkKKZ_lEp2JswjbJ5bW2ncsvna9NeJu81cqqs,5192
+ostruct/cli/cli.py,sha256=RCHjwx2mbRx9N-L1GeMgROqskvipjpwmavVh2z_Etds,8746
+ostruct/cli/click_options.py,sha256=NFcs6amLBtVLOjR6smNbGmDHwBpAXrpxQy5KCiLKPo4,34203
+ostruct/cli/code_interpreter.py,sha256=M8gyPy17s5lu8TsvXMDes4wi78iwqz_yoAQ4axeuhwM,23264
+ostruct/cli/commands/__init__.py,sha256=KuEoh7UF9CWis3VHZ6LAwoRcZrpG8oq9VSQRl1NjEo8,622
+ostruct/cli/commands/list_models.py,sha256=yeuQpUGAmRr4uOHS7teuVHkC9dkqN0yKDOEw_n-ehi0,4662
+ostruct/cli/commands/run.py,sha256=oq2ZXCQehFJnUV34nC9TEaJL8Qb2aZrHAoLu0x3TR2M,16805
+ostruct/cli/commands/update_registry.py,sha256=7DQrPlCJScPVgE2HbFAM7UMap-EdYu58AQWfpI-H7Gw,2483
+ostruct/cli/config.py,sha256=KxkJGxvRiiDr7oinwZVaDqtzRcYyQZ1xcoCtvykq6F4,10143
+ostruct/cli/constants.py,sha256=zyUwq4fladlCsfPnBPh7rSqfSwarbCL3I5HM1dIEf6I,2467
+ostruct/cli/cost_estimation.py,sha256=08hyE-kM5QYzj7y-KB3lMD_RxCMoM_Ve3-IQlSpJAo4,4483
+ostruct/cli/errors.py,sha256=vqdkGx2Znze61ms6BByOYg4D3ScBEK7OFP73PeJJufo,30865
+ostruct/cli/exit_codes.py,sha256=gdvB1dpu0LalEUZrofpk5K6aTQ24n5AfkAK5umludHU,365
+ostruct/cli/explicit_file_processor.py,sha256=mKYQCW4bodk8Ida0sGw8m5MmbiaMCAYvoHUXzU1KDSE,19210
+ostruct/cli/field_utils.py,sha256=bcRi1qQ0Ac2UCfrKSQ677_yu-VzaShm_zN7QLf98qc0,1939
+ostruct/cli/file_info.py,sha256=rNQSkUDUL3qbalovRu1unTixLVDzJ0HU01eFQYlMXlM,21443
+ostruct/cli/file_list.py,sha256=AmnQnXyI1djVbp_pv2VwK2VAqZQpSiTIXPbwu3_wCRQ,23431
+ostruct/cli/file_search.py,sha256=6JvThbrauznfr-nX4M_VG7kRQbSLG9YOQomLR9_IqPE,17566
+ostruct/cli/file_utils.py,sha256=JZprQ-1LHQzI3eBfeCIS6VmxTa2fGUZHygGC8gcwpJM,24367
+ostruct/cli/help_json.py,sha256=IDArJBtPTTMM2KVt36t1PBY72totKH9tVAsRnPuEPcA,8223
+ostruct/cli/json_extract.py,sha256=ZleIxat8g-JnA9VVqWgJaKxN7QzL25itQ8aP0Gb5e4Q,2650
+ostruct/cli/mcp_integration.py,sha256=zC24TZScr-Vio2Zq0lPBJVmATVWoIm2pfWwnO3ztQJ8,18791
+ostruct/cli/model_creation.py,sha256=HGo8Qv7eBF8Co463IR7RcbTCQcaOvd_cBGuRodRCAa4,23261
+ostruct/cli/model_validation.py,sha256=j2az3q88-Ljm2cMMgZ8p_-gcp1vKQnWCknnw0y0YlAw,6675
+ostruct/cli/params.py,sha256=D4j_I6vZYN-lOeqHWyAmLSxAT3u77CUXVvf6sx27Uvo,6353
+ostruct/cli/path_utils.py,sha256=j44q1OoLkqMErgK-qEuhuIZ1VyzqRIvNgxR1et9PoXA,4813
+ostruct/cli/plan_assembly.py,sha256=pCz2fH3MNbUVODMw43_fb-e61vgo5N0GBrZ1VlShs1M,11656
+ostruct/cli/plan_printing.py,sha256=_OSrnaLKi0nLdSSHnf6exaIhJT5YPedKh_8nYgqkluI,12837
+ostruct/cli/progress.py,sha256=rj9nVEco5UeZORMbzd7mFJpFGJjbH9KbBFh5oTE5Anw,3415
+ostruct/cli/progress_reporting.py,sha256=cQoMsRCBlIdRIefGwpBEX744H9pfpD5TdT8sB180hfI,11665
+ostruct/cli/quick_ref_help.py,sha256=_AWPcdxDj9v6DOX6yecahv7dfV38-TwB4sK5HsWmIbo,5014
+ostruct/cli/registry_updates.py,sha256=ohiHdlfrocvThpR_ZjMyqulDKFjRM1hIFKOlNzpaqHg,5138
+ostruct/cli/rich_config.py,sha256=DChXWG97pQRm_QZCTdOIpBhvuIfJXDlqT48vnBdnYKc,9904
+ostruct/cli/runner.py,sha256=a7Zkp4Wn9x6sMmtVtGEwLQ8i8ctTvKo2w36n6WpbuLM,74672
+ostruct/cli/schema_utils.py,sha256=9LnsjxEKg6RIfXQB3nS3pyDggm5n-4-thXf92897gJU,3590
+ostruct/cli/schema_validation.py,sha256=ohEuxJ0KF93qphj0JSZDnrxDn0C2ZU37g-U2JY03onM,8154
+ostruct/cli/security/__init__.py,sha256=Ix0AXDgxJaR0TtR-sG1353DtUF1BPujgjcaA28Cvgh4,898
+ostruct/cli/security/allowed_checker.py,sha256=ceNUEDiTirClq9Kvosytlm01JWj0J37JdiRzLsw3zD8,3462
+ostruct/cli/security/base.py,sha256=q9YUdHEj2eg5w8GEw5403E9OQKIjZbEiaWsvYFnCGLw,1359
+ostruct/cli/security/case_manager.py,sha256=I_ZJSyntLuGx5qVzze559CI-OxsaNPSibkAN8zZ7PvE,2345
+ostruct/cli/security/errors.py,sha256=8jYJFRQyEXIH3Wd2ATWORVoqbDg7qwu0TsuROpsqNfU,5254
+ostruct/cli/security/normalization.py,sha256=6UoFAl8cbvOUETMauyvmYogaoVhJm9WybGcS84biwh8,5488
+ostruct/cli/security/safe_joiner.py,sha256=PHowCeBAkfHfPqRwuO5Com0OemGuq3cHkdu2p9IYNT0,7107
+ostruct/cli/security/security_manager.py,sha256=VQbWxOp76mm8OCpCTtkzBrBh5nb-dKWQbxdZdZdFShM,36419
+ostruct/cli/security/symlink_resolver.py,sha256=wtZdJ_T_0FOy6B1P5ty1odEXQk9vr8BzlWeAFD4huJE,16744
+ostruct/cli/security/types.py,sha256=38qBfUSaYB0NXyOq9DytTg4OnievLSsA4ysI88YdaFY,3545
+ostruct/cli/security/windows_paths.py,sha256=qxC2H2kLwtmQ7YePYde3UrmOJcGnsLEebDLh242sUaI,13453
+ostruct/cli/sentinel.py,sha256=69faYPrhVJmEpYNLsCtf1HF96aan3APqXZdIjxBNZYo,798
+ostruct/cli/serialization.py,sha256=ec0UswDE2onwtZVUoZaMCsGv6zW_tSKdBng2qVo6Ucs,704
+ostruct/cli/services.py,sha256=nLYUbF3DDNuilh7j9q_atUOjTAWta7bxTS3G-zkveaA,21621
+ostruct/cli/template_debug.py,sha256=PEU9w10lIWPaMHbY2_uPr2HwM3154V1aIJ8mc_A5rSQ,25283
+ostruct/cli/template_debug_help.py,sha256=KqKYFIbE81HxTHWT-A2naLdk8PUsTNHTXkLusleGUD4,9178
+ostruct/cli/template_env.py,sha256=mxJPoA4DwbJKQIg2wLmqEsXarR1HrDiR8PhwKNKnAEQ,3535
+ostruct/cli/template_extensions.py,sha256=_lomtDGMGxMfpw05v_-daJ0JbhRm_r_-uEJlPAjbpkI,2699
+ostruct/cli/template_filters.py,sha256=ulo5jRo62zmkApYvDUjO5imUS5osec7eoeYwJsbuMKk,34566
+ostruct/cli/template_io.py,sha256=yUWO-8rZnSdX97DTMSEX8fG9CP1ISsOhm2NZN3Fab9A,8821
+ostruct/cli/template_processor.py,sha256=Y9GMCuA5lASse_AzDCgu8VdcmsAhxQn8qyG546cvBE0,30150
+ostruct/cli/template_rendering.py,sha256=at8RiT9v0peJUBRwDgX1-WJ6pDDMDO0H33MwuWlkowM,15831
+ostruct/cli/template_schema.py,sha256=ckH4rUZnEgfm_BHS9LnMGr8LtDxRmZ0C6UBVrSp8KTc,19604
+ostruct/cli/template_utils.py,sha256=MZdXXjL-x-IXX-5Y8GWopGNBkDE2ItLdCuCl0QWFR_U,14968
+ostruct/cli/template_validation.py,sha256=3wUBoZJZKt0C5TVaT0nmjH_ehyw4Gn1yEBnMDDE8qLU,14327
+ostruct/cli/token_utils.py,sha256=r4KPEO3Sec18Q6mU0aClK6XGShvusgUggXEQgEPPlaA,1369
+ostruct/cli/token_validation.py,sha256=DGc5yyScy0iTvvuF2DaDUgRQaIqVIcm9ZZtuVEyy_oI,10276
+ostruct/cli/types.py,sha256=qQ5mc4OAK8ChVrgaJ9VSn3gS75byrOonjlsc9WdgibE,2782
+ostruct/cli/unattended_operation.py,sha256=kI95SSVJC_taxORXQYrce_qLEnuKc6edwn9tMOye-qs,9383
+ostruct/cli/unicode_compat.py,sha256=bDeVZdWkDv74jVt4AsBl10tRra0v7kV04SNAMyR3q0U,9508
+ostruct/cli/upload_manager.py,sha256=m8BpVRJc7Ag9Ln5bAQPGMtisHSP0m7VVcXhHnqZ5CjI,16368
+ostruct/cli/utils.py,sha256=DV8KAx46rl3GgXLydVhrP6A1xY7ofyir3hEKUslSfek,2149
+ostruct/cli/validators.py,sha256=SRJozxcXgIdbjF0Jv5z2rSbOzeXiTYpzbZKc_WF-5HE,23882
+ostruct/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ostruct_cli-1.0.0.dist-info/LICENSE,sha256=DmGAkaYzhrdzTB9Y2Rvfzd3mJiF9ZrTOhxN8t6wrfHA,1098
+ostruct_cli-1.0.0.dist-info/METADATA,sha256=X6YXB3suiMvexCSUvF0FQUpJk6iotxfF00-F3vmeXqQ,31311
+ostruct_cli-1.0.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+ostruct_cli-1.0.0.dist-info/entry_points.txt,sha256=NFq9IuqHVTem0j9zKjV8C1si_zGcP1RL6Wbvt9fUDXw,48
+ostruct_cli-1.0.0.dist-info/RECORD,,

ostruct/cli/commands/quick_ref.py

@@ -1,54 +0,0 @@
-"""Quick reference command for ostruct CLI."""
-
-import click
-
-
-@click.command("quick-ref")
-def quick_reference() -> None:
-    """Show quick reference for file routing and common usage patterns."""
-    quick_ref = """
-🚀 OSTRUCT QUICK REFERENCE
-
-📁 FILE ROUTING:
-  -ft FILE    📄 Template access only       (config files, small data)
-  -fc FILE    💻 Code Interpreter upload    (data files, scripts)
-  -fs FILE    🔍 File Search vector store   (documents, manuals)
-
-  -dt DIR     📁 Template directory         (config dirs, reference data)
-  -dc DIR     📂 Code execution directory   (datasets, code repos)
-  -ds DIR     📁 Search directory           (documentation, knowledge)
-
-🔄 ADVANCED ROUTING:
-  --file-for code-interpreter data.csv      Single tool, single file
-  --file-for file-search docs.pdf           Single tool, single file
-  --file-for code-interpreter shared.json --file-for file-search shared.json   Multi-tool routing
-
-🏷️  VARIABLES:
-  -V name=value                             Simple string variables
-  -J config='{"key":"value"}'               JSON structured data
-
-🔌 TOOLS:
-  --web-search                              🌐 Real-time web search for current info
-  --mcp-server label@https://server.com/sse MCP server integration
-  --timeout 7200                           2-hour timeout for long operations
-
-⚡ COMMON PATTERNS:
-  # Basic template rendering
-  ostruct run template.j2 schema.json -V env=prod
-
-  # Data analysis with Code Interpreter
-  ostruct run analysis.j2 schema.json -fc data.csv -V task=analyze
-
-  # Document search + processing
-  ostruct run search.j2 schema.json -fs docs/ -ft config.yaml
-
-  # Multi-tool workflow
-  ostruct run workflow.j2 schema.json -fc raw_data.csv -fs knowledge/ -ft config.json
-
-  # Current information research
-  ostruct run research.j2 schema.json --web-search -V topic="latest AI developments"
-
-📖 Full help: ostruct run --help
-📖 Documentation: https://ostruct.readthedocs.io
-"""
-    click.echo(quick_ref)

ostruct/cli/template_optimizer.py

@@ -1,478 +0,0 @@
-"""Automatic template optimization system for improved LLM performance."""
-
-import re
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Dict, List, Match, Optional, Set
-
-try:
-    from jinja2 import Environment
-    from jinja2.nodes import For, Name
-
-    JINJA2_AVAILABLE = True
-except ImportError:
-    JINJA2_AVAILABLE = False
-
-
-@dataclass
-class OptimizationResult:
-    """Result of template optimization process."""
-
-    optimized_template: str
-    transformations: List[str]
-    files_moved: List[str]
-    inline_files_kept: List[str]
-    optimization_time_ms: float
-
-    @property
-    def has_optimizations(self) -> bool:
-        """Check if any optimizations were applied."""
-        return bool(self.transformations)
-
-
-class TemplateOptimizer:
-    """Automatic prompt optimization using pure text manipulation.
-
-    This optimizer applies prompt engineering best practices to improve LLM performance:
-    - Moves large file content to structured appendices
-    - Keeps small values inline for context
-    - Generates natural language references
-    - Maintains deterministic and fast processing
-    """
-
-    def __init__(self) -> None:
-        """Initialize the template optimizer."""
-        self.file_references: Dict[str, str] = {}
-        self.dir_references: Dict[str, str] = {}
-        self.optimization_log: List[str] = []
-        self.inline_threshold = (
-            200  # Characters threshold for inline vs appendix
-        )
-        self.small_value_threshold = (
-            50  # Very small values stay inline regardless
-        )
-
-    def _get_loop_variables(self, template_content: str) -> Set[str]:
-        """Extract loop variables from template to avoid optimizing them.
-
-        Args:
-            template_content: Template content to analyze
-
-        Returns:
-            Set of variable names used in for loops
-        """
-        if not JINJA2_AVAILABLE:
-            # Fallback: return common loop variable names
-            return {
-                "file",
-                "item",
-                "element",
-                "entry",
-                "record",
-                "row",
-                "line",
-            }
-
-        try:
-            env = Environment()
-            ast = env.parse(template_content)
-            loop_vars = set()
-
-            def visit_node(node: Any) -> None:
-                """Recursively visit AST nodes to find loop variables."""
-                if isinstance(node, For):
-                    # Handle single loop variable: {% for item in items %}
-                    if isinstance(node.target, Name):
-                        loop_vars.add(node.target.name)
-                    # Handle tuple unpacking: {% for key, value in items %}
-                    elif hasattr(node.target, "items"):
-                        for item in node.target.items:
-                            if isinstance(item, Name):
-                                loop_vars.add(item.name)
-
-                # Recursively visit child nodes
-                for child in node.iter_child_nodes():
-                    visit_node(child)
-
-            visit_node(ast)
-            return loop_vars
-
-        except Exception:
-            # If AST parsing fails, return common loop variable names as fallback
-            return {
-                "file",
-                "item",
-                "element",
-                "entry",
-                "record",
-                "row",
-                "line",
-            }
-
-    def optimize_for_llm(
-        self, template_content: str, step_tracker: Optional[Any] = None
-    ) -> OptimizationResult:
-        """Apply prompt engineering best practices for files and directories.
-
-        Args:
-            template_content: Original template content
-            step_tracker: Optional step tracker for detailed optimization logging
-
-        Returns:
-            OptimizationResult with optimized template and metadata
-        """
-        import time
-
-        start_time = time.time()
-
-        # Reset state for new optimization
-        self.file_references.clear()
-        self.dir_references.clear()
-        self.optimization_log.clear()
-
-        # Log initial step
-        if step_tracker:
-            step_tracker.log_step(
-                "Initial template loaded",
-                "",
-                template_content,
-                "Starting optimization process with original template",
-            )
-
-        # Get loop variables to avoid optimizing them
-        loop_variables = self._get_loop_variables(template_content)
-
-        optimized = template_content
-        inline_files_kept = []
-
-        # Step 1: Find and optimize file_content() calls
-        file_pattern = r'{{\s*([^}]*\.content|file_content\([^)]+\)|[^}]*\[["\'][^"\']*["\']\]\.content)\s*}}'
-
-        def replace_file_reference(match: Match[str]) -> str:
-            full_match = match.group(0)
-            content_expr = match.group(1)
-
-            # Extract file path from various patterns
-            file_path = self._extract_file_path(content_expr, loop_variables)
-            if not file_path:
-                return full_match  # Keep original if can't parse
-
-            # Check if content should stay inline
-            try:
-                if self._should_stay_inline(file_path):
-                    inline_files_kept.append(file_path)
-                    return full_match  # Keep inline
-
-                # Generate reference for large files
-                reference = self._generate_file_reference_text(file_path)
-                self.file_references[file_path] = reference
-                self.optimization_log.append(f"Moved {file_path} to appendix")
-                return reference
-
-            except Exception:
-                # If any error, keep original
-                return full_match
-
-        # Track file content optimization step
-        pre_file_opt = optimized
-        optimized = re.sub(file_pattern, replace_file_reference, optimized)
-
-        if step_tracker and pre_file_opt != optimized:
-            step_tracker.log_step(
-                "File content optimization",
-                pre_file_opt,
-                optimized,
-                f"Moved {len(self.file_references)} files to appendix, kept {len(inline_files_kept)} inline",
-            )
-
-        # Step 2: Optimize directory content references
-        dir_pattern = (
-            r"{{\s*([^}]*\.(files|content)|[^}]*\.files\[[^]]*\])\s*}}"
-        )
-
-        def replace_dir_reference_with_loop_check(match: Match[str]) -> str:
-            return self._replace_dir_reference(match, loop_variables)
-
-        # Track directory optimization step
-        pre_dir_opt = optimized
-        optimized = re.sub(
-            dir_pattern, replace_dir_reference_with_loop_check, optimized
-        )
-
-        if step_tracker and pre_dir_opt != optimized:
-            step_tracker.log_step(
-                "Directory reference optimization",
-                pre_dir_opt,
-                optimized,
-                f"Converted {len(self.dir_references)} directory references to natural language",
-            )
-
-        # Step 3: Build comprehensive appendix if we moved files
-        if self.file_references or self.dir_references:
-            pre_appendix = optimized
-            appendix = self._build_complete_appendix()
-            optimized += "\n\n" + appendix
-            self.optimization_log.append(
-                "Built structured appendix with moved content"
-            )
-
-            if step_tracker:
-                step_tracker.log_step(
-                    "Appendix generation",
-                    pre_appendix,
-                    optimized,
-                    f"Generated appendix with {len(self.file_references)} files and {len(self.dir_references)} directories",
-                )
-
-        optimization_time = (time.time() - start_time) * 1000
-
-        return OptimizationResult(
-            optimized_template=optimized,
-            transformations=self.optimization_log.copy(),
-            files_moved=list(self.file_references.keys()),
-            inline_files_kept=inline_files_kept,
-            optimization_time_ms=optimization_time,
-        )
-
-    def _extract_file_path(
-        self, content_expr: str, loop_variables: Set[str]
-    ) -> Optional[str]:
-        """Extract file path from various Jinja2 content expressions.
-
-        Args:
-            content_expr: Jinja2 expression containing file reference
-            loop_variables: Set of loop variables to avoid
-
-        Returns:
-            Extracted file path or None if not found
-        """
-        # Pattern 1: file_content('path') or file_content("path")
-        match = re.search(r'file_content\(["\']([^"\']+)["\']\)', content_expr)
-        if match:
-            return match.group(1)
-
-        # Pattern 2: variable.content - handle ALL single-file variables
-        match = re.search(r"(\w+)\.content", content_expr)
-        if match:
-            var_name = match.group(1)
-            # Skip if this is a loop variable
-            if var_name in loop_variables:
-                return None
-            # Return placeholder for ANY .content access to prevent directory misclassification
-            return f"${var_name}"
-
-        # Pattern 3: files['filename'].content
-        match = re.search(
-            r'files\[["\']([^"\']+)["\']\]\.content', content_expr
-        )
-        if match:
-            return match.group(1)
-
-        return None
-
-    def _should_stay_inline(self, file_path: str) -> bool:
-        """Determine if file content should stay inline.
-
-        Args:
-            file_path: Path to the file
-
-        Returns:
-            True if content should stay inline, False if moved to appendix
-        """
-        # Variable references (${var}) should stay inline for now
-        if file_path.startswith("$"):
-            return True
-
-        try:
-            # Check actual file size if path exists
-            path = Path(file_path)
-            if path.exists() and path.is_file():
-                content = path.read_text(encoding="utf-8", errors="ignore")
-                content_size = len(content.strip())
-
-                # Very small files stay inline
-                if content_size <= self.small_value_threshold:
-                    return True
-
-                # Check if it's a simple value (no newlines, short)
-                if (
-                    content_size <= self.inline_threshold
-                    and "\n" not in content.strip()
-                ):
-                    return True
-
-                return False
-
-        except Exception:
-            pass
-
-        # Default: move to appendix for unknown files
-        return False
-
-    def _generate_file_reference_text(self, file_path: str) -> str:
-        """Generate natural language references using pattern matching.
-
-        Args:
-            file_path: Path to the file
-
-        Returns:
-            Natural language reference text
-        """
-        filename = Path(file_path).name.lower()
-
-        # Pattern-based natural language generation
-        if "config" in filename:
-            return f"the configuration details in <file:{file_path}>"
-        elif "rule" in filename or "policy" in filename:
-            return f"the business rules defined in <file:{file_path}>"
-        elif "schema" in filename:
-            return f"the schema definition in <file:{file_path}>"
-        elif "example" in filename or "sample" in filename:
-            return f"the example shown in <file:{file_path}>"
-        elif filename.endswith((".json", ".yaml", ".yml")):
-            return f"the structured data from <file:{file_path}>"
-        elif filename.endswith((".py", ".js", ".ts", ".java", ".cpp", ".c")):
-            return f"the code implementation in <file:{file_path}>"
-        elif filename.endswith((".md", ".txt", ".rst")):
-            return f"the documentation in <file:{file_path}>"
-        elif filename.endswith((".csv", ".xlsx", ".tsv")):
-            return f"the data from <file:{file_path}>"
-        elif "readme" in filename:
-            return f"the project overview in <file:{file_path}>"
-        elif "changelog" in filename or "history" in filename:
-            return f"the change history in <file:{file_path}>"
-        else:
-            return f"the content of <file:{file_path}>"
-
-    def _replace_dir_reference(
-        self, match: Match[str], loop_variables: Set[str]
-    ) -> str:
-        """Replace directory content references with natural language.
-
-        Args:
-            match: Regex match object for directory reference
-            loop_variables: Set of loop variables to avoid
-
-        Returns:
-            Natural language reference or original text
-        """
-        full_match = match.group(0)
-        content_expr = match.group(1)
-
-        # Extract directory variable name
-        dir_match = re.search(r"(\w+)\.(?:files|content)", content_expr)
-        if not dir_match:
-            return full_match
-
-        dir_var = dir_match.group(1)
-
-        # Skip if this is a loop variable
-        if dir_var in loop_variables:
-            return full_match
-
-        # Skip if this is a single-file variable accessed via .content
-        # These should be handled by the file pattern, not directory pattern
-        if content_expr.endswith(".content"):
-            # Check if this would be handled by _extract_file_path
-            file_path = self._extract_file_path(content_expr, loop_variables)
-            if file_path:
-                return full_match  # Let file pattern handle it
-
-        reference = f"the files and subdirectories in <dir:{dir_var}>"
-        self.dir_references[dir_var] = reference
-        self.optimization_log.append(
-            f"Moved directory {dir_var} content to appendix"
-        )
-
-        return reference
-
-    def _build_complete_appendix(self) -> str:
-        """Build comprehensive appendix with moved content.
-
-        Returns:
-            Formatted appendix section
-        """
-        appendix_lines = [
-            "=" * 50,
-            "APPENDIX: Referenced Files and Directories",
-            "=" * 50,
-        ]
-
-        if self.file_references:
-            appendix_lines.extend(["", "FILES:"])
-            for file_path, reference in self.file_references.items():
-                appendix_lines.append(f"  <file:{file_path}>")
-                appendix_lines.append(f"    Referenced as: {reference}")
-                # Note: Actual file content would be injected here during template rendering
-                appendix_lines.append(
-                    f"    {{{{ file_content('{file_path}') }}}}"
-                )
-                appendix_lines.append("")
-
-        if self.dir_references:
-            appendix_lines.extend(["DIRECTORIES:"])
-            for dir_var, reference in self.dir_references.items():
-                appendix_lines.append(f"  <dir:{dir_var}>")
-                appendix_lines.append(f"    Referenced as: {reference}")
-                appendix_lines.append(f"    {{{{ {dir_var} }}}}")
-                appendix_lines.append("")
-
-        return "\n".join(appendix_lines)
-
-    def get_optimization_stats(self) -> Dict[str, int]:
-        """Get statistics about the last optimization.
-
-        Returns:
-            Dictionary with optimization statistics
-        """
-        return {
-            "files_moved": len(self.file_references),
-            "directories_moved": len(self.dir_references),
-            "total_transformations": len(self.optimization_log),
-        }
-
-
-def optimize_template_for_llm(
-    template_content: str, step_tracker: Optional[Any] = None
-) -> OptimizationResult:
-    """Convenience function for template optimization.
-
-    Args:
-        template_content: Original template content
-        step_tracker: Optional step tracker for detailed optimization logging
-
-    Returns:
-        OptimizationResult with optimized template
-    """
-    optimizer = TemplateOptimizer()
-    return optimizer.optimize_for_llm(template_content, step_tracker)
-
-
-def is_optimization_beneficial(
-    template_content: str, threshold_chars: int = 1000
-) -> bool:
-    """Check if template optimization would be beneficial.
-
-    Args:
-        template_content: Template content to analyze
-        threshold_chars: Minimum size to consider optimization
-
-    Returns:
-        True if optimization would likely help
-    """
-    # Check template size
-    if len(template_content) < threshold_chars:
-        return False
-
-    # Check for file content patterns
-    file_patterns = [
-        r"{{\s*[^}]*\.content\s*}}",
-        r"{{\s*file_content\([^)]+\)\s*}}",
-        r"{{\s*[^}]*\.files\s*}}",
-    ]
-
-    for pattern in file_patterns:
-        if re.search(pattern, template_content):
-            return True
-
-    return False