adjust logging

Author: anhnh2002

codewiki/cli/adapters/doc_generator.py

@@ -71,27 +71,26 @@ def __init__(
         self._configure_backend_logging()
 
     def _configure_backend_logging(self):
-        """Configure backend logger for CLI use."""
+        """Configure backend logger for CLI use with colored output."""
+        from codewiki.src.be.dependency_analyzer.utils.logging_config import ColoredFormatter
+        
         # Get backend logger (parent of all backend modules)
         backend_logger = logging.getLogger('codewiki.src.be')
 
         # Remove existing handlers to avoid duplicates
         backend_logger.handlers.clear()
 
         if self.verbose:
-            # In verbose mode, show DEBUG and above
-            backend_logger.setLevel(logging.DEBUG)
+            # In verbose mode, show INFO and above
+            backend_logger.setLevel(logging.INFO)
 
             # Create console handler with formatting
             console_handler = logging.StreamHandler(sys.stdout)
-            console_handler.setLevel(logging.DEBUG)
+            console_handler.setLevel(logging.INFO)
 
-            # Create formatter with timestamp and minimal formatting for cleaner output
-            formatter = logging.Formatter(
-                '[%(asctime)s] %(message)s',
-                datefmt='%H:%M:%S'
-            )
-            console_handler.setFormatter(formatter)
+            # Use colored formatter for better readability
+            colored_formatter = ColoredFormatter()
+            console_handler.setFormatter(colored_formatter)
 
             # Add handler to logger
             backend_logger.addHandler(console_handler)
@@ -103,9 +102,9 @@ def _configure_backend_logging(self):
             console_handler = logging.StreamHandler(sys.stderr)
             console_handler.setLevel(logging.WARNING)
 
-            # Simple formatter for warnings/errors
-            formatter = logging.Formatter('%(levelname)s: %(message)s')
-            console_handler.setFormatter(formatter)
+            # Use colored formatter even for warnings/errors
+            colored_formatter = ColoredFormatter()
+            console_handler.setFormatter(colored_formatter)
 
             backend_logger.addHandler(console_handler)
 

codewiki/src/be/agent_orchestrator.py

@@ -115,13 +115,13 @@ async def process_module(self, module_name: str, components: Dict[str, Node],
         # 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}")
+            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):
-            logger.info(f"Module docs already exists at {docs_path}")
+            logger.info(f"✓ Module docs already exists at {docs_path}")
             return module_tree
 
         # Run agent

codewiki/src/be/agent_tools/generate_sub_module_documentations.py

@@ -39,9 +39,11 @@ async def generate_sub_module_documentation(
 
     for sub_module_name, core_component_ids in sub_module_specs.items():
 
-        tabs = "   " * deps.current_depth
+        # Create visual indentation for nested modules
+        indent = "  " * deps.current_depth
+        arrow = "└─" if deps.current_depth > 0 else "→"
 
-        logger.info(f"{tabs}Generating documentation for sub-module: {sub_module_name}")
+        logger.info(f"{indent}{arrow} Generating documentation for sub-module: {sub_module_name}")
 
         num_tokens = count_tokens(format_potential_core_components(core_component_ids, ctx.deps.components)[-1])
 

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

@@ -38,7 +38,6 @@ def analyze_code_files(self, code_files: List[Dict], base_dir: str) -> Dict:
         self.functions = {}
         self.call_relationships = []
 
-        logger.debug("Analyzing all code files")
         files_analyzed = 0
         for file_info in code_files:
             logger.debug(f"Analyzing: {file_info['path']}")
@@ -111,19 +110,13 @@ def _analyze_code_file(self, repo_dir: str, file_info: Dict):
             repo_dir: Repository directory path
             file_info: File information dictionary
         """
-        # file_path = Path(repo_dir) / file_info["path"]
 
-        # logger.debug(f"Reading content of {file_path}")
-        # try:
-        #     with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
-        #         content = f.read()
         base = Path(repo_dir)
         file_path = base / file_info["path"]
-        logger.debug(f"Reading content of {file_path}")
+
         try:
             content = safe_open_text(base, file_path)
             language = file_info["language"]
-            logger.debug(f"Analyzing {language} file: {file_path}")
             if language == "python":
                 self._analyze_python_file(file_path, content, repo_dir)
             elif language == "javascript":
@@ -138,10 +131,10 @@ def _analyze_code_file(self, repo_dir: str, file_info: Dict):
                 self._analyze_c_file(file_path, content, repo_dir)
             elif language == "cpp":
                 self._analyze_cpp_file(file_path, content, repo_dir)
-            else:
-                logger.warning(
-                    f"Unsupported language for call graph analysis: {language} for file {file_path}"
-                )
+            # else:
+            #     logger.warning(
+            #         f"Unsupported language for call graph analysis: {language} for file {file_path}"
+            #     )
 
         except Exception as e:
             logger.error(f"⚠️ Error analyzing {file_path}: {str(e)}")
@@ -180,18 +173,13 @@ def _analyze_javascript_file(self, file_path: str, content: str, repo_dir: str):
             repo_dir: Repository base directory
         """
         try:
-            logger.debug(f"Starting tree-sitter JavaScript analysis for {file_path}")
 
             from codewiki.src.be.dependency_analyzer.analyzers.javascript import analyze_javascript_file_treesitter
 
             functions, relationships = analyze_javascript_file_treesitter(
                 file_path, content, repo_path=repo_dir
             )
 
-            logger.debug(
-                f"Tree-sitter JavaScript analysis completed for {file_path}: {len(functions)} functions, {len(relationships)} relationships"
-            )
-
             for func in functions:
                 func_id = func.id if func.id else f"{file_path}:{func.name}"
                 self.functions[func_id] = func
@@ -210,18 +198,13 @@ def _analyze_typescript_file(self, file_path: str, content: str, repo_dir: str):
             content: File content string
         """
         try:
-            logger.debug(f"Starting tree-sitter TypeScript analysis for {file_path}")
 
             from codewiki.src.be.dependency_analyzer.analyzers.typescript import analyze_typescript_file_treesitter
 
             functions, relationships = analyze_typescript_file_treesitter(
                 file_path, content, repo_path=repo_dir
             )
 
-            logger.debug(
-                f"Tree-sitter TypeScript analysis completed for {file_path}: {len(functions)} functions, {len(relationships)} relationships"
-            )
-
             for func in functions:
                 func_id = func.id if func.id else f"{file_path}:{func.name}"
                 self.functions[func_id] = func
@@ -285,9 +268,6 @@ def _analyze_java_file(self, file_path: str, content: str, repo_dir: str):
 
         try:
             functions, relationships = analyze_java_file(file_path, content, repo_path=repo_dir)
-            logger.debug(
-                f"Found {len(functions)} functions and {len(relationships)} relationships in {file_path}"
-            )
             for func in functions:
                 func_id = func.id if func.id else f"{file_path}:{func.name}"
                 self.functions[func_id] = func
@@ -309,9 +289,6 @@ def _analyze_csharp_file(self, file_path: str, content: str, repo_dir: str):
 
         try:
             functions, relationships = analyze_csharp_file(file_path, content, repo_path=repo_dir)
-            logger.debug(
-                f"Found {len(functions)} functions and {len(relationships)} relationships in {file_path}"
-            )
 
             for func in functions:
                 func_id = func.id if func.id else f"{file_path}:{func.name}"
@@ -328,7 +305,6 @@ def _resolve_call_relationships(self):
         Attempts to match function calls to actual function definitions,
         handling cross-language calls where possible.
         """
-        logger.debug("Building function lookup table for resolving relationships.")
         func_lookup = {}
         for func_id, func_info in self.functions.items():
             func_lookup[func_id] = func_id
@@ -375,9 +351,6 @@ def _deduplicate_relationships(self):
                 seen.add(key)
                 unique_relationships.append(rel)
 
-        logger.debug(
-            f"Removed {len(self.call_relationships) - len(unique_relationships)} duplicate relationships."
-        )
         self.call_relationships = unique_relationships
 
     def _generate_visualization_data(self) -> Dict:
@@ -391,7 +364,6 @@ def _generate_visualization_data(self) -> Dict:
         """
         cytoscape_elements = []
 
-        logger.debug(f"Adding {len(self.functions)} function nodes.")
         for func_id, func_info in self.functions.items():
             node_classes = []
             if func_info.node_type == "method":
@@ -425,7 +397,6 @@ def _generate_visualization_data(self) -> Dict:
             )
 
         resolved_rels = [r for r in self.call_relationships if r.is_resolved]
-        logger.debug(f"Adding {len(resolved_rels)} relationship edges.")
         for rel in resolved_rels:
             cytoscape_elements.append(
                 {
@@ -493,9 +464,6 @@ def _select_most_connected_nodes(self, target_count: int):
             target_count: The number of nodes to select
         """
         if len(self.functions) <= target_count:
-            logger.debug(
-                f"Have {len(self.functions)} functions, target is {target_count} - keeping all"
-            )
             return
 
         if not self.call_relationships:
@@ -537,8 +505,3 @@ def _select_most_connected_nodes(self, target_count: int):
             if rel.caller in selected_func_ids and rel.callee in selected_func_ids
         ]
 
-        logger.debug(
-            f"Node selection: {original_func_count} -> {len(self.functions)} functions, "
-            f"{original_rel_count} -> {len(self.call_relationships)} relationships"
-        )
-        logger.debug(f"Kept {len(selected_func_ids)} most connected nodes (target: {target_count})")

codewiki/src/be/dependency_analyzer/dependency_graphs_builder.py

@@ -73,7 +73,8 @@ def build_dependency_graph(self) -> tuple[Dict[str, Any], List[str]]:
                 if components[leaf_node].component_type in ["class", "interface", "struct"]:
                     keep_leaf_nodes.append(leaf_node)
                 else:
-                    logger.debug(f"Leaf node {leaf_node} is a {components[leaf_node].component_type}, removing it")
+                    # logger.debug(f"Leaf node {leaf_node} is a {components[leaf_node].component_type}, removing it")
+                    pass
             else:
                 logger.warning(f"Leaf node {leaf_node} not found in components, removing it")
 

codewiki/src/be/dependency_analyzer/topo_sort.py

@@ -313,9 +313,11 @@ def concise_node(leaf_nodes: Set[str]) -> Set[str]:
                 if components[leaf_node].component_type in ["class", "interface", "struct"]:
                     keep_leaf_nodes.append(leaf_node)
                 else:
-                    logger.debug(f"Leaf node {leaf_node} is a {components[leaf_node].component_type}, removing it")
+                    # logger.debug(f"Leaf node {leaf_node} is a {components[leaf_node].component_type}, removing it")
+                    pass
             else:
-                logger.debug(f"Leaf node {leaf_node} not found in components, removing it")
+                # logger.debug(f"Leaf node {leaf_node} not found in components, removing it")
+                pass
 
         return keep_leaf_nodes