adjust logs

Author: anhnh2002

codewiki/src/be/agent_orchestrator.py

@@ -29,7 +29,7 @@
 #         )
 
 #     logfire.instrument_pydantic_ai()
-#     logger.info(f"Logfire configured successfully for project: {logfire_project}")
+#     logger.debug(f"Logfire configured successfully for project: {logfire_project}")
 
 # except Exception as e:
 #     logger.warning(f"Failed to configure logfire: {e}")
@@ -45,10 +45,11 @@
     LEAF_SYSTEM_PROMPT,
     format_user_prompt,
 )
-from .utils import is_complex_module
+from codewiki.src.be.utils import is_complex_module
 from codewiki.src.config import (
     Config,
     MODULE_TREE_FILENAME,
+    OVERVIEW_FILENAME,
 )
 from codewiki.src.utils import file_manager
 from codewiki.src.be.dependency_analyzer.models.core import Node
@@ -88,7 +89,7 @@ def create_agent(self, module_name: str, components: Dict[str, Any],
     async def process_module(self, module_name: str, components: Dict[str, Node], 
                            core_component_ids: List[str], module_path: List[str], working_dir: str) -> Dict[str, Any]:
         """Process a single module and generate its documentation."""
-        logger.info(f"Processing module: {module_name}")
+        logger.debug(f"Processing module: {module_name}")
 
         # Load or create module tree
         module_tree_path = os.path.join(working_dir, MODULE_TREE_FILENAME)
@@ -111,6 +112,12 @@ async def process_module(self, module_name: str, components: Dict[str, Node],
             config=self.config
         )
 
+        # check if overview docs already exists
+        overview_docs_path = os.path.join(working_dir, OVERVIEW_FILENAME)
+        if os.path.exists(overview_docs_path):
+            logger.info(f"Overview docs already exists at {overview_docs_path}")
+            return module_tree
+
         # check if module docs already exists
         docs_path = os.path.join(working_dir, f"{module_name}.md")
         if os.path.exists(docs_path):
@@ -131,7 +138,7 @@ async def process_module(self, module_name: str, components: Dict[str, Node],
 
             # Save updated module tree
             file_manager.save_json(deps.module_tree, module_tree_path)
-            logger.info(f"Successfully processed module: {module_name}")
+            logger.debug(f"Successfully processed module: {module_name}")
 
             return deps.module_tree
 

codewiki/src/be/cluster_modules.py

@@ -54,7 +54,7 @@ def cluster_modules(
     potential_core_components, potential_core_components_with_code = format_potential_core_components(leaf_nodes, components)
 
     if count_tokens(potential_core_components_with_code) <= MAX_TOKEN_PER_MODULE:
-        logger.info(f"Skipping clustering for {current_module_name} because the potential core components are too few: {count_tokens(potential_core_components_with_code)} tokens")
+        logger.debug(f"Skipping clustering for {current_module_name} because the potential core components are too few: {count_tokens(potential_core_components_with_code)} tokens")
         return {}
 
     prompt = format_cluster_prompt(potential_core_components, current_module_tree, current_module_name)
@@ -79,7 +79,7 @@ def cluster_modules(
 
     # check if the module tree is valid
     if len(module_tree) <= 1:
-        logger.info(f"Skipping clustering for {current_module_name} because the module tree is too small: {len(module_tree)} modules")
+        logger.debug(f"Skipping clustering for {current_module_name} because the module tree is too small: {len(module_tree)} modules")
         return {}
 
     if current_module_tree == {}:

codewiki/src/be/dependency_analyzer/analysis/analysis_service.py

@@ -55,7 +55,7 @@ def analyze_local_repository(
             Dict with analysis results including nodes and relationships
         """
         try:
-            logger.info(f"Analyzing local repository at {repo_path}")
+            logger.debug(f"Analyzing local repository at {repo_path}")
 
             # Get repo analyzer to find files
             repo_analyzer = RepoAnalyzer()
@@ -71,9 +71,9 @@ def analyze_local_repository(
             # Limit number of files
             if len(code_files) > max_files:
                 code_files = code_files[:max_files]
-                logger.info(f"Limited analysis to {max_files} files")
+                logger.debug(f"Limited analysis to {max_files} files")
 
-            logger.info(f"Analyzing {len(code_files)} files")
+            logger.debug(f"Analyzing {len(code_files)} files")
 
             # Analyze files
             result = self.call_graph_analyzer.analyze_code_files(code_files, repo_path)
@@ -115,18 +115,18 @@ def analyze_repository_full(
         """
         temp_dir = None
         try:
-            logger.info(f"Starting full analysis of {github_url}")
+            logger.debug(f"Starting full analysis of {github_url}")
 
             temp_dir = self._clone_repository(github_url)
             repo_info = self._parse_repository_info(github_url)
 
-            logger.info("Analyzing repository file structure...")
+            logger.debug("Analyzing repository file structure...")
             structure_result = self._analyze_structure(temp_dir, include_patterns, exclude_patterns)
-            logger.info(f"Found {structure_result['summary']['total_files']} files to analyze.")
+            logger.debug(f"Found {structure_result['summary']['total_files']} files to analyze.")
 
-            logger.info("Starting call graph analysis...")
+            logger.debug("Starting call graph analysis...")
             call_graph_result = self._analyze_call_graph(structure_result["file_tree"], temp_dir)
-            logger.info(
+            logger.debug(
                 f"Call graph analysis complete. Found {call_graph_result['call_graph']['total_functions']} functions."
             )
 
@@ -152,10 +152,10 @@ def analyze_repository_full(
                 readme_content=readme_content,
             )
 
-            logger.info(f"Cleaning up temporary repository directory: {temp_dir}")
+            logger.debug(f"Cleaning up temporary repository directory: {temp_dir}")
             self._cleanup_repository(temp_dir)
 
-            logger.info(
+            logger.debug(
                 f"Analysis completed: {analysis_result.summary['total_functions']} functions found"
             )
             return analysis_result
@@ -185,7 +185,7 @@ def analyze_repository_structure_only(
         """
         temp_dir = None
         try:
-            logger.info(f"Starting structure analysis of {github_url}")
+            logger.debug(f"Starting structure analysis of {github_url}")
 
             temp_dir = self._clone_repository(github_url)
             repo_info = self._parse_repository_info(github_url)
@@ -203,7 +203,7 @@ def analyze_repository_structure_only(
 
             self._cleanup_repository(temp_dir)
 
-            logger.info(
+            logger.debug(
                 f"Structure analysis completed: {result['file_summary']['total_files']} files found"
             )
             return result
@@ -216,9 +216,9 @@ def analyze_repository_structure_only(
 
     def _clone_repository(self, github_url: str) -> str:
         """Clone repository and return temp dir path."""
-        logger.info(f"Cloning {github_url}...")
+        logger.debug(f"Cloning {github_url}...")
         temp_dir = clone_repository(github_url)
-        logger.info(f"Repository cloned to {temp_dir}")
+        logger.debug(f"Repository cloned to {temp_dir}")
         self._temp_directories.append(temp_dir)
         return temp_dir
 
@@ -233,7 +233,7 @@ def _analyze_structure(
         exclude_patterns: Optional[List[str]],
     ) -> Dict[str, Any]:
         """Analyze repository file structure with filtering."""
-        logger.info(
+        logger.debug(
             f"Initializing RepoAnalyzer with include: {include_patterns}, exclude: {exclude_patterns}"
         )
         repo_analyzer = RepoAnalyzer(include_patterns, exclude_patterns)
@@ -246,12 +246,12 @@ def _read_readme_file(self, repo_dir: str) -> Optional[str]:
         #     readme_path = Path(repo_dir) / name
         #     if readme_path.exists():
         #         try:
-        #             logger.info(f"Found README file at {readme_path}")
+        #             logger.debug(f"Found README file at {readme_path}")
         #             return readme_path.read_text(encoding="utf-8")
         #         except Exception as e:
         #             logger.warning(f"Could not read README file at {readme_path}: {e}")
         #             return None
-        # logger.info("No README file found in repository root.")
+        # logger.debug("No README file found in repository root.")
         # return None
         base = Path(repo_dir)
         possible_readme_names = ["README.md", "README", "readme.md", "README.txt"]
@@ -260,12 +260,12 @@ def _read_readme_file(self, repo_dir: str) -> Optional[str]:
             if p.exists():
                 try:
                     assert_safe_path(base, p)
-                    logger.info(f"Found README file at {p}")
+                    logger.debug(f"Found README file at {p}")
                     return safe_open_text(base, p, encoding="utf-8")
                 except Exception as e:
                     logger.warning(f"Skipping unsafe/ unreadable README at {p}: {e}")
                     return None
-        logger.info("No README file found in repository root.")
+        logger.debug("No README file found in repository root.")
         return None
 
     def _analyze_call_graph(self, file_tree: Dict[str, Any], repo_dir: str) -> Dict[str, Any]:
@@ -277,12 +277,12 @@ def _analyze_call_graph(self, file_tree: Dict[str, Any], repo_dir: str) -> Dict[
         - JavaScript/TypeScript AST analysis (planned)
         - Additional language support (future)
         """
-        logger.info("Extracting code files from file tree...")
+        logger.debug("Extracting code files from file tree...")
         code_files = self.call_graph_analyzer.extract_code_files(file_tree)
 
-        logger.info(f"Found {len(code_files)} total code files. Filtering for supported languages.")
+        logger.debug(f"Found {len(code_files)} total code files. Filtering for supported languages.")
         supported_files = self._filter_supported_languages(code_files)
-        logger.info(f"Analyzing {len(supported_files)} supported files.")
+        logger.debug(f"Analyzing {len(supported_files)} supported files.")
 
         result = self.call_graph_analyzer.analyze_code_files(supported_files, repo_dir)
 
@@ -321,7 +321,7 @@ def _get_supported_languages(self) -> List[str]:
 
     def _cleanup_repository(self, temp_dir: str):
         """Clean up cloned repository."""
-        logger.info(f"Attempting to clean up {temp_dir}")
+        logger.debug(f"Attempting to clean up {temp_dir}")
         cleanup_repository(temp_dir)
         if temp_dir in self._temp_directories:
             self._temp_directories.remove(temp_dir)

codewiki/src/be/dependency_analyzer/ast_parser.py

@@ -26,7 +26,7 @@ def __init__(self, repo_path: str):
         self.analysis_service = AnalysisService()
 
     def parse_repository(self, filtered_folders: List[str] = None) -> Dict[str, Node]:
-        logger.info(f"Parsing repository at {self.repo_path}")
+        logger.debug(f"Parsing repository at {self.repo_path}")
 
         structure_result = self.analysis_service._analyze_structure(
             self.repo_path, 
@@ -41,7 +41,7 @@ def parse_repository(self, filtered_folders: List[str] = None) -> Dict[str, Node
 
         self._build_components_from_analysis(call_graph_result)
 
-        logger.info(f"Found {len(self.components)} components across {len(self.modules)} modules")
+        logger.debug(f"Found {len(self.components)} components across {len(self.modules)} modules")
         return self.components
 
     def _build_components_from_analysis(self, call_graph_result: Dict):
@@ -141,5 +141,5 @@ def save_dependency_graph(self, output_path: str):
         with open(output_path, 'w', encoding='utf-8') as f:
             json.dump(result, f, indent=2, ensure_ascii=False)
 
-        logger.info(f"Saved {len(self.components)} components to {output_path}")
+        logger.debug(f"Saved {len(self.components)} components to {output_path}")
         return result

codewiki/src/be/dependency_analyzer/dependency_graphs_builder.py

@@ -41,7 +41,7 @@ def build_dependency_graph(self) -> tuple[Dict[str, Any], List[str]]:
 
         filtered_folders = None
         # if os.path.exists(filtered_folders_path):
-        #     logger.info(f"Loading filtered folders from {filtered_folders_path}")
+        #     logger.debug(f"Loading filtered folders from {filtered_folders_path}")
         #     filtered_folders = file_manager.load_json(filtered_folders_path)
         # else:
         #     # Parse repository

codewiki/src/be/dependency_analyzer/topo_sort.py

@@ -321,7 +321,7 @@ def concise_node(leaf_nodes: Set[str]) -> Set[str]:
 
     concise_leaf_nodes = concise_node(leaf_nodes)
     if len(concise_leaf_nodes) >= 400:
-        logger.info(f"Leaf nodes are too many ({len(concise_leaf_nodes)}), removing dependencies of other nodes")
+        logger.debug(f"Leaf nodes are too many ({len(concise_leaf_nodes)}), removing dependencies of other nodes")
         # Remove nodes that are dependencies of other nodes
         for node, deps in acyclic_graph.items():
             for dep in deps:

codewiki/src/be/documentation_generator.py

@@ -70,7 +70,7 @@ def create_documentation_metadata(self, working_dir: str, components: Dict[str,
 
         metadata_path = os.path.join(working_dir, "metadata.json")
         file_manager.save_json(metadata, metadata_path)
-        logger.info(f"Documentation metadata saved to: {metadata_path}")
+        logger.debug(f"Documentation metadata saved to: {metadata_path}")
 
     def get_processing_order(self, module_tree: Dict[str, Any], parent_path: List[str] = []) -> List[tuple[List[str], str]]:
         """Get the processing order using topological sort (leaf modules first)."""
@@ -135,7 +135,7 @@ async def generate_module_documentation(self, components: Dict[str, Any], leaf_n
 
         # Get processing order (leaf modules first)
         processing_order = self.get_processing_order(first_module_tree)
-        logger.info(f"Processing {len(processing_order)} modules in dependency order:\n{processing_order}")
+        logger.debug(f"Processing {len(processing_order)} modules in dependency order:\n{processing_order}")
 
         # Process modules in dependency order
         final_module_tree = module_tree
@@ -175,12 +175,12 @@ async def generate_module_documentation(self, components: Dict[str, Any], leaf_n
                     continue
 
             # Generate repo overview
-            logger.info(f"Generating repo overview")
+            logger.debug(f"Generating repo overview")
             final_module_tree = await self.generate_parent_module_docs(
                 [], working_dir
             )
         else:
-            logger.info(f"Processing whole repo because repo can fit in the context window")
+            logger.debug(f"Processing whole repo because repo can fit in the context window")
             repo_name = os.path.basename(os.path.normpath(self.config.repo_path))
             final_module_tree = await self.agent_orchestrator.process_module(
                 repo_name, components, leaf_nodes, [], working_dir
@@ -197,12 +197,18 @@ async def generate_parent_module_docs(self, module_path: List[str],
         """Generate documentation for a parent module based on its children's documentation."""
         module_name = module_path[-1] if len(module_path) >= 1 else os.path.basename(os.path.normpath(self.config.repo_path))
 
-        logger.info(f"Generating parent documentation for: {module_name}")
+        logger.debug(f"Generating parent documentation for: {module_name}")
 
         # Load module tree
         module_tree_path = os.path.join(working_dir, MODULE_TREE_FILENAME)
         module_tree = file_manager.load_json(module_tree_path)
-        
+
+        # check if parent docs already exists
+        parent_docs_path = os.path.join(working_dir, f"{module_name if len(module_path) >= 1 else OVERVIEW_FILENAME.replace('.md', '')}.md")
+        if os.path.exists(parent_docs_path):
+            logger.info(f"Parent docs already exists at {parent_docs_path}")
+            return module_tree
+
         # Create repo structure with 1-depth children docs and target indicator
         repo_structure = self.build_overview_structure(module_tree, module_path, working_dir)
 
@@ -220,10 +226,9 @@ async def generate_parent_module_docs(self, module_path: List[str],
             # Parse and save parent documentation
             parent_content = parent_docs.split("<OVERVIEW>")[1].split("</OVERVIEW>")[0].strip()
             # parent_content = prompt
-            parent_docs_path = os.path.join(working_dir, f"{module_name if len(module_path) >= 1 else OVERVIEW_FILENAME.replace('.md', '')}.md")
             file_manager.save_text(parent_content, parent_docs_path)
 
-            logger.info(f"Successfully generated parent documentation for: {module_name}")
+            logger.debug(f"Successfully generated parent documentation for: {module_name}")
             return module_tree
 
         except Exception as e:
@@ -236,8 +241,8 @@ async def run(self) -> None:
             # Build dependency graph
             components, leaf_nodes = self.graph_builder.build_dependency_graph()
 
-            logger.info(f"Found {len(leaf_nodes)} leaf nodes")
-            # logger.info(f"Leaf nodes:\n{'\n'.join(sorted(leaf_nodes)[:200])}")
+            logger.debug(f"Found {len(leaf_nodes)} leaf nodes")
+            # logger.debug(f"Leaf nodes:\n{'\n'.join(sorted(leaf_nodes)[:200])}")
             # exit()
 
             # Cluster modules
@@ -248,16 +253,16 @@ async def run(self) -> None:
 
             # Check if module tree exists
             if os.path.exists(first_module_tree_path):
-                logger.info(f"Module tree found at {first_module_tree_path}")
+                logger.debug(f"Module tree found at {first_module_tree_path}")
                 module_tree = file_manager.load_json(first_module_tree_path)
             else:
-                logger.info(f"Module tree not found at {module_tree_path}, clustering modules")
+                logger.debug(f"Module tree not found at {module_tree_path}, clustering modules")
                 module_tree = cluster_modules(leaf_nodes, components, self.config)
                 file_manager.save_json(module_tree, first_module_tree_path)
 
             file_manager.save_json(module_tree, module_tree_path)
 
-            logger.info(f"Grouped components into {len(module_tree)} modules")
+            logger.debug(f"Grouped components into {len(module_tree)} modules")
 
             # Generate module documentation using dynamic programming approach
             # This processes leaf modules first, then parent modules
@@ -266,9 +271,9 @@ async def run(self) -> None:
             # Create documentation metadata
             self.create_documentation_metadata(working_dir, components, len(leaf_nodes))
 
-            logger.info(f"Documentation generation completed successfully using dynamic programming!")
-            logger.info(f"Processing order: leaf modules → parent modules → repository overview")
-            logger.info(f"Documentation saved to: {working_dir}")
+            logger.debug(f"Documentation generation completed successfully using dynamic programming!")
+            logger.debug(f"Processing order: leaf modules → parent modules → repository overview")
+            logger.debug(f"Documentation saved to: {working_dir}")
 
         except Exception as e:
             logger.error(f"Documentation generation failed: {str(e)}")

codewiki/src/be/main.py

@@ -50,7 +50,7 @@ async def main() -> None:
         await doc_generator.run()
 
     except KeyboardInterrupt:
-        logger.info("Documentation generation interrupted by user")
+        logger.debug("Documentation generation interrupted by user")
     except Exception as e:
         logger.error(f"Unexpected error: {str(e)}")
         raise