codinsight 0.0.7__tar.gz → 0.0.8__tar.gz

codinsight-0.0.8/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: codinsight
+Version: 0.0.8
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.10.5
+Requires-Dist: pandas>=2.3.1
+Requires-Dist: pycodestyle>=2.14.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydocstyle>=6.3.0
+Requires-Dist: pytest>=8.4.1
+Requires-Dist: pytest-cov>=6.2.1
+Requires-Dist: radon>=6.0.1
+Requires-Dist: reportlab>=4.4.3
+Requires-Dist: scikit-learn>=1.7.1
+
+Codinsight - 複数ファイル解析の利用方法
+
+概要
+- 複数のファイルやディレクトリを再帰的に走査し、既存の解析エンジン（Style/Struct/Readability/Redundancy/Algorithm/Complexity/Quality）で一括解析を実行
+- 拡張子のフィルタや除外パターン（node_modules, .git など）に対応
+- 結果をファイル単位と集約統計（平均など）で取得可能
+- Pydantic BaseModel で JSON 化が容易
+
+## API 使用例
+
+```python
+from code_insight.core import CodeAnalysisType
+from code_insight.multi_analysis import MultiFileAnalyzer
+
+analyzer = MultiFileAnalyzer(
+    exts={".py"},
+    excludes={"node_modules", "target", ".git", ".venv", "__pycache__"},
+)
+result = analyzer.analyze(
+    ["src", "tests"],
+    [CodeAnalysisType.STYLE, CodeAnalysisType.STRUCT],
+)
+print(result.model_dump_json())
+```
+
+## 設定のカスタマイズ
+
+```python
+from code_insight.core import CodeAnalysis, AnalysisConfigs, CodeAnalysisType
+from code_insight.code_analysis.quality import QualityAnalysisConfig
+from code_insight.code_analysis.redundancy import RedundancyAnalysisConfig
+from code_insight.code_analysis.style import StyleAnalysisConfig
+
+# カスタム設定の作成
+configs = AnalysisConfigs(
+    quality=QualityAnalysisConfig(
+        long_param_threshold=3,  # デフォルト: 5
+        enabled=True
+    ),
+    redundancy=RedundancyAnalysisConfig(
+        long_function_lines_threshold=30,  # デフォルト: 50
+        long_function_complexity_threshold=8,  # デフォルト: 10
+        ignored_function_names={"main", "__init__", "setup"}
+    ),
+    style=StyleAnalysisConfig(
+        function_name_pattern=r"^[a-z_][a-z0-9_]*$",  # snake_case
+        class_name_pattern=r"^[A-Z][a-zA-Z0-9]*$"     # PascalCase
+    )
+)
+
+# 設定を使用した解析
+analysis = CodeAnalysis(source_code, configs)
+result = analysis.analyze([CodeAnalysisType.QUALITY, CodeAnalysisType.REDUNDANCY])
+
+# 複数ファイル解析での設定使用
+analyzer = MultiFileAnalyzer(configs=configs)
+result = analyzer.analyze(["src"], [CodeAnalysisType.STYLE])
+```
+
+### 設定可能な項目
+
+#### Quality解析
+- `long_param_threshold`: 長引数関数の閾値（デフォルト: 5）
+- `enabled`: 解析の有効/無効（デフォルト: True）
+
+#### Redundancy解析
+- `long_function_lines_threshold`: 長大関数の行数閾値（デフォルト: 50）
+- `long_function_complexity_threshold`: 長大関数の複雑度閾値（デフォルト: 10）
+- `ignored_function_names`: 未使用コード検出で無視する関数名（デフォルト: {"main", "__init__", "__main__"}）
+
+#### Style解析
+- `function_name_pattern`: 関数名の正規表現パターン（デフォルト: snake_case）
+- `class_name_pattern`: クラス名の正規表現パターン（デフォルト: PascalCase）
+
+#### その他の解析エンジン
+- Algorithm, Complexity, Readability, Structの各解析エンジンにも同様の設定項目があります
+
+主なオプション
+- exts: 対象拡張子のセット（デフォルト: {".py"}）
+- excludes: 除外ディレクトリ名のセット（デフォルト: {"node_modules", "target", ".git", ".venv", "__pycache__"}）
+
+返却データの構造
+- files: 各ファイルの解析結果（解析タイプ名 → メトリクス辞書）
+- aggregate:
+  - total_files: 解析対象に収集されたファイル数
+  - analyzed_files: 実際に解析に成功したファイル数
+  - errors: 解析時にエラーとなったファイルパスの一覧
+  - by_type_avg: 解析タイプごとの各数値メトリクスの平均値
+
+注意
+- 現時点では直列処理のみ対応。大規模データや並列化は将来的な拡張予定

codinsight-0.0.8/README.md

@@ -0,0 +1,91 @@
+Codinsight - 複数ファイル解析の利用方法
+
+概要
+- 複数のファイルやディレクトリを再帰的に走査し、既存の解析エンジン（Style/Struct/Readability/Redundancy/Algorithm/Complexity/Quality）で一括解析を実行
+- 拡張子のフィルタや除外パターン（node_modules, .git など）に対応
+- 結果をファイル単位と集約統計（平均など）で取得可能
+- Pydantic BaseModel で JSON 化が容易
+
+## API 使用例
+
+```python
+from code_insight.core import CodeAnalysisType
+from code_insight.multi_analysis import MultiFileAnalyzer
+
+analyzer = MultiFileAnalyzer(
+    exts={".py"},
+    excludes={"node_modules", "target", ".git", ".venv", "__pycache__"},
+)
+result = analyzer.analyze(
+    ["src", "tests"],
+    [CodeAnalysisType.STYLE, CodeAnalysisType.STRUCT],
+)
+print(result.model_dump_json())
+```
+
+## 設定のカスタマイズ
+
+```python
+from code_insight.core import CodeAnalysis, AnalysisConfigs, CodeAnalysisType
+from code_insight.code_analysis.quality import QualityAnalysisConfig
+from code_insight.code_analysis.redundancy import RedundancyAnalysisConfig
+from code_insight.code_analysis.style import StyleAnalysisConfig
+
+# カスタム設定の作成
+configs = AnalysisConfigs(
+    quality=QualityAnalysisConfig(
+        long_param_threshold=3,  # デフォルト: 5
+        enabled=True
+    ),
+    redundancy=RedundancyAnalysisConfig(
+        long_function_lines_threshold=30,  # デフォルト: 50
+        long_function_complexity_threshold=8,  # デフォルト: 10
+        ignored_function_names={"main", "__init__", "setup"}
+    ),
+    style=StyleAnalysisConfig(
+        function_name_pattern=r"^[a-z_][a-z0-9_]*$",  # snake_case
+        class_name_pattern=r"^[A-Z][a-zA-Z0-9]*$"     # PascalCase
+    )
+)
+
+# 設定を使用した解析
+analysis = CodeAnalysis(source_code, configs)
+result = analysis.analyze([CodeAnalysisType.QUALITY, CodeAnalysisType.REDUNDANCY])
+
+# 複数ファイル解析での設定使用
+analyzer = MultiFileAnalyzer(configs=configs)
+result = analyzer.analyze(["src"], [CodeAnalysisType.STYLE])
+```
+
+### 設定可能な項目
+
+#### Quality解析
+- `long_param_threshold`: 長引数関数の閾値（デフォルト: 5）
+- `enabled`: 解析の有効/無効（デフォルト: True）
+
+#### Redundancy解析
+- `long_function_lines_threshold`: 長大関数の行数閾値（デフォルト: 50）
+- `long_function_complexity_threshold`: 長大関数の複雑度閾値（デフォルト: 10）
+- `ignored_function_names`: 未使用コード検出で無視する関数名（デフォルト: {"main", "__init__", "__main__"}）
+
+#### Style解析
+- `function_name_pattern`: 関数名の正規表現パターン（デフォルト: snake_case）
+- `class_name_pattern`: クラス名の正規表現パターン（デフォルト: PascalCase）
+
+#### その他の解析エンジン
+- Algorithm, Complexity, Readability, Structの各解析エンジンにも同様の設定項目があります
+
+主なオプション
+- exts: 対象拡張子のセット（デフォルト: {".py"}）
+- excludes: 除外ディレクトリ名のセット（デフォルト: {"node_modules", "target", ".git", ".venv", "__pycache__"}）
+
+返却データの構造
+- files: 各ファイルの解析結果（解析タイプ名 → メトリクス辞書）
+- aggregate:
+  - total_files: 解析対象に収集されたファイル数
+  - analyzed_files: 実際に解析に成功したファイル数
+  - errors: 解析時にエラーとなったファイルパスの一覧
+  - by_type_avg: 解析タイプごとの各数値メトリクスの平均値
+
+注意
+- 現時点では直列処理のみ対応。大規模データや並列化は将来的な拡張予定

{codinsight-0.0.7 → codinsight-0.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codinsight"
-version = "0.0.7"
+version = "0.0.8"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

codinsight-0.0.8/src/code_insight/__init__.py

@@ -0,0 +1,56 @@
+from .code_analysis.algorithm import (
+    Algorithm,
+    AlgorithmAnalysisConfig,
+    AlgorithmAnalysisResult,
+)
+from .code_analysis.complexity import (
+    Complexity,
+    ComplexityAnalysisConfig,
+    ComplexityAnalysisResult,
+)
+from .code_analysis.quality import Quality, QualityAnalysisConfig, QualityAnalysisResult
+from .code_analysis.readability import (
+    Readability,
+    ReadabilityAnalysisConfig,
+    ReadabilityAnalysisResult,
+)
+from .code_analysis.redundancy import (
+    Redundancy,
+    RedundancyAnalysisConfig,
+    RedundancyAnalysisResult,
+)
+from .code_analysis.struct import Struct, StructAnalysisConfig, StructAnalysisResult
+from .code_analysis.style import Style, StyleAnalysisConfig, StyleAnalysisResult
+from .core import AnalysisConfigs, CodeAnalysis, CodeAnalysisType
+from .multi_analysis import MultiAnalysisResult, MultiFileAnalyzer
+from .trend_analysis.trend_analysis import TrendAnalysis
+
+__all__ = [
+    "CodeAnalysis",
+    "CodeAnalysisType",
+    "AnalysisConfigs",
+    "MultiFileAnalyzer",
+    "MultiAnalysisResult",
+    "Readability",
+    "ReadabilityAnalysisResult",
+    "ReadabilityAnalysisConfig",
+    "Algorithm",
+    "AlgorithmAnalysisResult",
+    "AlgorithmAnalysisConfig",
+    "Complexity",
+    "ComplexityAnalysisResult",
+    "ComplexityAnalysisConfig",
+    "Quality",
+    "QualityAnalysisResult",
+    "QualityAnalysisConfig",
+    "Redundancy",
+    "RedundancyAnalysisResult",
+    "RedundancyAnalysisConfig",
+    "Struct",
+    "StructAnalysisResult",
+    "StructAnalysisConfig",
+    "Style",
+    "StyleAnalysisResult",
+    "StyleAnalysisConfig",
+    "TrendAnalysis",
+]

codinsight-0.0.8/src/code_insight/code_analysis/abstract.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+
+class BaseAnalysisConfig(BaseModel):
+    """解析設定のベースクラス"""
+
+    enabled: bool = True
+
+
+class BaseAnalysisResult(BaseModel):
+    """解析結果のベースモデル"""
+
+
+R = TypeVar("R", bound=BaseAnalysisResult)
+C = TypeVar("C", bound=BaseAnalysisConfig)
+
+
+class AbstractAnalysis(ABC, Generic[R, C]):
+    """解析抽象クラス"""
+
+    config: C
+
+    def __init__(self, config: C | None = None) -> None:
+        """コンストラクタ"""
+        self.config = config or self.get_default_config()
+
+    @abstractmethod
+    def get_default_config(self) -> C:
+        """デフォルト設定を取得"""
+        raise NotImplementedError("get_default_config method must be implemented")
+
+    @abstractmethod
+    def analyze(self, source_code: str) -> R:
+        """コードを解析する"""
+        raise NotImplementedError("analyze method must be implemented")

{codinsight-0.0.7 → codinsight-0.0.8}/src/code_insight/code_analysis/algorithm.py

@@ -1,7 +1,22 @@
 import ast
 from typing import Set
 
-from code_insight.code_analysis.abstract import AbstractAnalysis, BaseAnalysisResult
+from code_insight.code_analysis.abstract import (
+    AbstractAnalysis,
+    BaseAnalysisConfig,
+    BaseAnalysisResult,
+)
+
+
+class AlgorithmAnalysisConfig(BaseAnalysisConfig):
+    """
+    アルゴリズム解析設定
+    * 最大ネスト深度閾値
+    * サイクロマティック複雑度閾値
+    """
+
+    max_nesting_depth_threshold: int = 4
+    cyclomatic_complexity_threshold: float = 5.0
 
 
 class AlgorithmAnalysisResult(BaseAnalysisResult):
@@ -18,8 +33,6 @@ class AlgorithmAnalysisResult(BaseAnalysisResult):
         * lambda式の数
         * リスト内包表記の数
         * map/filter/reduce呼び出しの数
-    * 循環的複雑度
-        * McCabe複雑度の平均
     * ネスト深度
         * 制御構文の最大ネスト深度
     """
@@ -32,55 +45,78 @@ class AlgorithmAnalysisResult(BaseAnalysisResult):
     lambda_count: int
     comprehension_count: int
     functional_call_count: int
-    cyclomatic_complexity: float
     max_nesting_depth: int
 
 
-class Algorithm(AbstractAnalysis[AlgorithmAnalysisResult]):
+class Algorithm(AbstractAnalysis[AlgorithmAnalysisResult, AlgorithmAnalysisConfig]):
     """解析クラス(アルゴリズム)"""
 
+    def __init__(self, config: AlgorithmAnalysisConfig | None = None) -> None:
+        """コンストラクタ"""
+        super().__init__(config)
+
+    def get_default_config(self) -> AlgorithmAnalysisConfig:
+        """デフォルト設定を取得"""
+        return AlgorithmAnalysisConfig()
+
     def analyze(self, source_code: str) -> AlgorithmAnalysisResult:
         """コード解析"""
+        if not self.config.enabled:
+            return AlgorithmAnalysisResult(
+                if_count=0,
+                for_count=0,
+                while_count=0,
+                try_count=0,
+                recursion_rate=0.0,
+                lambda_count=0,
+                comprehension_count=0,
+                functional_call_count=0,
+                max_nesting_depth=0,
+            )
+
+        tree = self.parse_source_code(source_code)
+
         return AlgorithmAnalysisResult(
-            if_count=self.get_if_count(source_code),
-            for_count=self.get_for_count(source_code),
-            while_count=self.get_while_count(source_code),
-            try_count=self.get_try_count(source_code),
-            recursion_rate=self.get_recursion_rate(source_code),
-            lambda_count=self.get_lambda_count(source_code),
-            comprehension_count=self.get_comprehension_count(source_code),
-            functional_call_count=self.get_functional_call_count(source_code),
-            cyclomatic_complexity=self.get_cyclomatic_complexity(source_code),
-            max_nesting_depth=self.get_max_nesting_depth(source_code),
+            if_count=self.get_if_count(source_code, tree),
+            for_count=self.get_for_count(source_code, tree),
+            while_count=self.get_while_count(source_code, tree),
+            try_count=self.get_try_count(source_code, tree),
+            recursion_rate=self.get_recursion_rate(source_code, tree),
+            lambda_count=self.get_lambda_count(source_code, tree),
+            comprehension_count=self.get_comprehension_count(source_code, tree),
+            functional_call_count=self.get_functional_call_count(source_code, tree),
+            max_nesting_depth=self.get_max_nesting_depth(source_code, tree),
         )
 
     def parse_source_code(self, source_code: str) -> ast.AST:
         """ソースコードを解析"""
         return ast.parse(source_code)
 
-    def get_if_count(self, source_code: str) -> int:
+    def get_if_count(self, source_code: str, tree: ast.AST | None = None) -> int:
         """if文の数を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         return sum(isinstance(node, ast.If) for node in ast.walk(tree))
 
-    def get_for_count(self, source_code: str) -> int:
+    def get_for_count(self, source_code: str, tree: ast.AST | None = None) -> int:
         """for文の数を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         return sum(isinstance(node, (ast.For, ast.AsyncFor)) for node in ast.walk(tree))
 
-    def get_while_count(self, source_code: str) -> int:
+    def get_while_count(self, source_code: str, tree: ast.AST | None = None) -> int:
         """while文の数を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         return sum(isinstance(node, ast.While) for node in ast.walk(tree))
 
-    def get_try_count(self, source_code: str) -> int:
+    def get_try_count(self, source_code: str, tree: ast.AST | None = None) -> int:
         """try-except文の数を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         return sum(isinstance(node, ast.Try) for node in ast.walk(tree))
 
-    def get_recursion_rate(self, source_code: str) -> float:
+    def get_recursion_rate(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> float:
         """再帰関数の割合を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         function_names: Set[str] = set()
         recursive_functions: Set[str] = set()
 
@@ -102,14 +138,16 @@ class Algorithm(AbstractAnalysis[AlgorithmAnalysisResult]):
             return len(recursive_functions) / len(function_names)
         return 0.0
 
-    def get_lambda_count(self, source_code: str) -> int:
+    def get_lambda_count(self, source_code: str, tree: ast.AST | None = None) -> int:
         """lambda式の数を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         return sum(isinstance(node, ast.Lambda) for node in ast.walk(tree))
 
-    def get_comprehension_count(self, source_code: str) -> int:
+    def get_comprehension_count(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> int:
         """内包表記の数を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         return sum(
             isinstance(
                 node, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
@@ -117,9 +155,11 @@ class Algorithm(AbstractAnalysis[AlgorithmAnalysisResult]):
             for node in ast.walk(tree)
         )
 
-    def get_functional_call_count(self, source_code: str) -> int:
+    def get_functional_call_count(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> int:
         """map/filter/reduce呼び出しの数を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         functional_names = {"map", "filter", "reduce"}
         count = 0
 
@@ -133,9 +173,11 @@ class Algorithm(AbstractAnalysis[AlgorithmAnalysisResult]):
 
         return count
 
-    def get_cyclomatic_complexity(self, source_code: str) -> float:
+    def get_cyclomatic_complexity(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> float:
         """循環的複雑度の平均を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         complexities = []
 
         for node in ast.walk(tree):
@@ -159,9 +201,11 @@ class Algorithm(AbstractAnalysis[AlgorithmAnalysisResult]):
 
         return complexity
 
-    def get_max_nesting_depth(self, source_code: str) -> int:
+    def get_max_nesting_depth(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> int:
         """制御構文の最大ネスト深度を取得"""
-        tree = self.parse_source_code(source_code)
+        tree = tree or self.parse_source_code(source_code)
         max_depth = 0
 
         def calculate_depth(node: ast.AST, current_depth: int = 0) -> None:

{codinsight-0.0.7 → codinsight-0.0.8}/src/code_insight/code_analysis/complexity.py

@@ -3,7 +3,18 @@ import ast
 import radon.complexity as cc
 import radon.metrics as metrics
 
-from code_insight.code_analysis.abstract import AbstractAnalysis, BaseAnalysisResult
+from code_insight.code_analysis.abstract import (
+    AbstractAnalysis,
+    BaseAnalysisConfig,
+    BaseAnalysisResult,
+)
+
+
+class ComplexityAnalysisConfig(BaseAnalysisConfig):
+    """複雑度解析設定"""
+
+    max_nesting_depth_threshold: int = 5
+    cognitive_complexity_threshold: float = 10.0
 
 
 class ComplexityAnalysisResult(BaseAnalysisResult):
@@ -31,19 +42,40 @@ class ComplexityAnalysisResult(BaseAnalysisResult):
     maintainability_index: float
 
 
-class Complexity(AbstractAnalysis[ComplexityAnalysisResult]):
+class Complexity(AbstractAnalysis[ComplexityAnalysisResult, ComplexityAnalysisConfig]):
     """解析クラス(複雑度)"""
 
+    def __init__(self, config: ComplexityAnalysisConfig | None = None) -> None:
+        """コンストラクタ"""
+        super().__init__(config)
+
+    def get_default_config(self) -> ComplexityAnalysisConfig:
+        """デフォルト設定を取得"""
+        return ComplexityAnalysisConfig()
+
     def analyze(self, source_code: str) -> ComplexityAnalysisResult:
         """コード解析"""
+        tree = ast.parse(source_code) if source_code.strip() else ast.parse("")
+        if not self.config.enabled:
+            return ComplexityAnalysisResult(
+                cyclomatic_complexity=0.0,
+                halstead_volume=0.0,
+                halstead_difficulty=0.0,
+                halstead_effort=0.0,
+                max_nesting_depth=0,
+                avg_nesting_depth=0.0,
+                cognitive_complexity=0.0,
+                maintainability_index=0.0,
+            )
+
         return ComplexityAnalysisResult(
             cyclomatic_complexity=self.get_cyclomatic_complexity(source_code),
             halstead_volume=self.get_halstead_volume(source_code),
             halstead_difficulty=self.get_halstead_difficulty(source_code),
             halstead_effort=self.get_halstead_effort(source_code),
-            max_nesting_depth=self.get_max_nesting_depth(source_code),
-            avg_nesting_depth=self.get_avg_nesting_depth(source_code),
-            cognitive_complexity=self.get_cognitive_complexity(source_code),
+            max_nesting_depth=self.get_max_nesting_depth(source_code, tree),
+            avg_nesting_depth=self.get_avg_nesting_depth(source_code, tree),
+            cognitive_complexity=self.get_cognitive_complexity(source_code, tree),
             maintainability_index=self.get_maintainability_index(source_code),
         )
 
@@ -105,13 +137,15 @@ class Complexity(AbstractAnalysis[ComplexityAnalysisResult]):
         except Exception:
             return 0.0
 
-    def get_max_nesting_depth(self, source_code: str) -> int:
+    def get_max_nesting_depth(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> int:
         """最大ネスト深度を取得"""
-        if not source_code.strip():
+        if not source_code.strip() and tree is None:
             return 0
 
         try:
-            tree = ast.parse(source_code)
+            tree = tree or ast.parse(source_code)
             max_depth = 0
 
             def calculate_depth(node: ast.AST, current_depth: int = 0) -> int:
@@ -142,13 +176,15 @@ class Complexity(AbstractAnalysis[ComplexityAnalysisResult]):
         except Exception:
             return 0
 
-    def get_avg_nesting_depth(self, source_code: str) -> float:
+    def get_avg_nesting_depth(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> float:
         """平均ネスト深度を取得"""
-        if not source_code.strip():
+        if not source_code.strip() and tree is None:
             return 0.0
 
         try:
-            tree = ast.parse(source_code)
+            tree = tree or ast.parse(source_code)
             depths = []
 
             def collect_depths(node: ast.AST, current_depth: int = 0) -> None:
@@ -166,13 +202,15 @@ class Complexity(AbstractAnalysis[ComplexityAnalysisResult]):
         except Exception:
             return 0.0
 
-    def get_cognitive_complexity(self, source_code: str) -> float:
+    def get_cognitive_complexity(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> float:
         """認知的複雑度を取得"""
-        if not source_code.strip():
+        if not source_code.strip() and tree is None:
             return 0.0
 
         try:
-            tree = ast.parse(source_code)
+            tree = tree or ast.parse(source_code)
             complexity = 0
 
             def calculate_cognitive_complexity(