Method _run_module_agent_sync

codewiki/src/be/caw_backend.py:206–324

(
        self,
        module_name: str,
        components: Dict[str, Node],
        core_component_ids: List[str],
        module_path: List[str],
        working_dir: str,
        start_depth: int = 1,
        module_tree: Dict[str, Any] | None = None,
    )

        )

    def _run_module_agent_sync(
        self,
        module_name: str,
        components: Dict[str, Node],
        core_component_ids: List[str],
        module_path: List[str],
        working_dir: str,
        start_depth: int = 1,
        module_tree: Dict[str, Any] | None = None,
    ) -> Dict[str, Any]:
        # ``start_depth`` lets the recursion preserve max_depth across nested
        # _run_module_agent_sync calls — each fresh deps object would otherwise
        # reset current_depth to 1 and silently bypass max_depth guards.
        # ``module_tree`` carries the parent's in-memory tree across the
        # recursion.  Reloading from disk only works at the top level — by the
        # time a sub-agent runs, the parent has staged new branches in memory
        # but has not yet saved (save happens after agent.completion returns).
        from codewiki.src.be.caw_toolkit import CawToolKit  # local import to avoid cycles

        config = self._config
        module_tree_path = os.path.join(working_dir, MODULE_TREE_FILENAME)
        if module_tree is None:
            module_tree = file_manager.load_json(module_tree_path)

        overview_docs_path = os.path.join(working_dir, OVERVIEW_FILENAME)
        if os.path.exists(overview_docs_path):
            logger.info("✓ Overview docs already exists at %s", overview_docs_path)
            return module_tree
        docs_path = os.path.join(working_dir, f"{module_name}.md")
        if os.path.exists(docs_path):
            logger.info("✓ Module docs already exists at %s", docs_path)
            return module_tree

        custom_instructions = config.get_prompt_addition()

        # Mirror PydanticAIBackend's early-cut: a module is only worth
        # delegating to sub-agents when it spans multiple files AND has enough
        # content to justify the cost AND we still have recursion budget.
        # Without this gate the caw path would give every multi-file sub-module
        # the recursive SYSTEM_PROMPT + delegation tool and fan out one extra
        # agent call per sub-spec even when a single leaf write would suffice.
        # See generate_sub_module_documentation_tool for the pydantic-ai
        # equivalent.
        _, components_with_code = format_potential_core_components(
            core_component_ids, components
        )
        num_tokens = count_tokens(components_with_code)
        can_delegate = (
            is_complex_module(components, core_component_ids)
            and start_depth < config.max_depth
            and num_tokens >= config.max_token_per_leaf_module
        )
        logger.info(f"Module {module_name} can delegate: {can_delegate} - is_complex_module: {is_complex_module(components, core_component_ids)} - start_depth: {start_depth} - num_tokens: {num_tokens} - max_depth: {config.max_depth} - max_token_per_leaf_module: {config.max_token_per_leaf_module}")

        if can_delegate:
            system_prompt = format_system_prompt(module_name, custom_instructions)
        else:
            system_prompt = format_leaf_system_prompt(module_name, custom_instructions)