codinsight 0.0.6__tar.gz → 0.0.7__tar.gz

{codinsight-0.0.6 → codinsight-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codinsight
-Version: 0.0.6
+Version: 0.0.7
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

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

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

codinsight-0.0.7/src/code_insight/__init__.py

@@ -0,0 +1,26 @@
+from .code_analysis.algorithm import Algorithm, AlgorithmAnalysisResult
+from .code_analysis.complexity import Complexity, ComplexityAnalysisResult
+from .code_analysis.readability import Readability, ReadabilityAnalysisResult
+from .code_analysis.redundancy import Redundancy, RedundancyAnalysisResult
+from .code_analysis.struct import Struct, StructAnalysisResult
+from .code_analysis.style import Style, StyleAnalysisResult
+from .core import CodeAnalysis, CodeAnalysisType
+from .trend_analysis.trend_analysis import TrendAnalysis
+
+__all__ = [
+    "CodeAnalysis",
+    "Readability",
+    "ReadabilityAnalysisResult",
+    "CodeAnalysisType",
+    "Style",
+    "StyleAnalysisResult",
+    "Struct",
+    "StructAnalysisResult",
+    "Redundancy",
+    "RedundancyAnalysisResult",
+    "Algorithm",
+    "AlgorithmAnalysisResult",
+    "Complexity",
+    "ComplexityAnalysisResult",
+    "TrendAnalysis",
+]

codinsight-0.0.7/src/code_insight/code_analysis/algorithm.py

@@ -0,0 +1,189 @@
+import ast
+from typing import Set
+
+from code_insight.code_analysis.abstract import AbstractAnalysis, BaseAnalysisResult
+
+
+class AlgorithmAnalysisResult(BaseAnalysisResult):
+    """
+    解析結果(アルゴリズム)
+    * 制御構文
+        * if文の数
+        * for文の数
+        * while文の数
+        * try-except文の数
+    * 再帰構造
+        * 再帰関数の割合
+    * FP的要素
+        * lambda式の数
+        * リスト内包表記の数
+        * map/filter/reduce呼び出しの数
+    * 循環的複雑度
+        * McCabe複雑度の平均
+    * ネスト深度
+        * 制御構文の最大ネスト深度
+    """
+
+    if_count: int
+    for_count: int
+    while_count: int
+    try_count: int
+    recursion_rate: float
+    lambda_count: int
+    comprehension_count: int
+    functional_call_count: int
+    cyclomatic_complexity: float
+    max_nesting_depth: int
+
+
+class Algorithm(AbstractAnalysis[AlgorithmAnalysisResult]):
+    """解析クラス(アルゴリズム)"""
+
+    def analyze(self, source_code: str) -> AlgorithmAnalysisResult:
+        """コード解析"""
+        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),
+        )
+
+    def parse_source_code(self, source_code: str) -> ast.AST:
+        """ソースコードを解析"""
+        return ast.parse(source_code)
+
+    def get_if_count(self, source_code: str) -> int:
+        """if文の数を取得"""
+        tree = 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:
+        """for文の数を取得"""
+        tree = 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:
+        """while文の数を取得"""
+        tree = 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:
+        """try-except文の数を取得"""
+        tree = 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:
+        """再帰関数の割合を取得"""
+        tree = self.parse_source_code(source_code)
+        function_names: Set[str] = set()
+        recursive_functions: Set[str] = set()
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                function_names.add(node.name)
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                for call_node in ast.walk(node):
+                    if (
+                        isinstance(call_node, ast.Call)
+                        and isinstance(call_node.func, ast.Name)
+                        and call_node.func.id == node.name
+                    ):
+                        recursive_functions.add(node.name)
+
+        if function_names:
+            return len(recursive_functions) / len(function_names)
+        return 0.0
+
+    def get_lambda_count(self, source_code: str) -> int:
+        """lambda式の数を取得"""
+        tree = 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:
+        """内包表記の数を取得"""
+        tree = self.parse_source_code(source_code)
+        return sum(
+            isinstance(
+                node, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
+            )
+            for node in ast.walk(tree)
+        )
+
+    def get_functional_call_count(self, source_code: str) -> int:
+        """map/filter/reduce呼び出しの数を取得"""
+        tree = self.parse_source_code(source_code)
+        functional_names = {"map", "filter", "reduce"}
+        count = 0
+
+        for node in ast.walk(tree):
+            if (
+                isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Name)
+                and node.func.id in functional_names
+            ):
+                count += 1
+
+        return count
+
+    def get_cyclomatic_complexity(self, source_code: str) -> float:
+        """循環的複雑度の平均を取得"""
+        tree = self.parse_source_code(source_code)
+        complexities = []
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                complexity = self._calculate_function_complexity(node)
+                complexities.append(complexity)
+
+        return sum(complexities) / len(complexities) if complexities else 0.0
+
+    def _calculate_function_complexity(self, func_node: ast.FunctionDef) -> int:
+        """関数の循環的複雑度を計算"""
+        complexity = 1
+
+        for node in ast.walk(func_node):
+            if isinstance(node, (ast.If, ast.While, ast.For, ast.AsyncFor)):
+                complexity += 1
+            elif isinstance(node, ast.Try):
+                complexity += len(node.handlers)
+            elif isinstance(node, ast.BoolOp):
+                complexity += len(node.values) - 1
+
+        return complexity
+
+    def get_max_nesting_depth(self, source_code: str) -> int:
+        """制御構文の最大ネスト深度を取得"""
+        tree = self.parse_source_code(source_code)
+        max_depth = 0
+
+        def calculate_depth(node: ast.AST, current_depth: int = 0) -> None:
+            nonlocal max_depth
+
+            if isinstance(
+                node,
+                (
+                    ast.If,
+                    ast.For,
+                    ast.AsyncFor,
+                    ast.While,
+                    ast.Try,
+                    ast.With,
+                    ast.AsyncWith,
+                ),
+            ):
+                current_depth += 1
+                max_depth = max(max_depth, current_depth)
+
+            for child in ast.iter_child_nodes(node):
+                calculate_depth(child, current_depth)
+
+        calculate_depth(tree)
+        return max_depth

codinsight-0.0.7/src/code_insight/code_analysis/complexity.py

@@ -0,0 +1,212 @@
+import ast
+
+import radon.complexity as cc
+import radon.metrics as metrics
+
+from code_insight.code_analysis.abstract import AbstractAnalysis, BaseAnalysisResult
+
+
+class ComplexityAnalysisResult(BaseAnalysisResult):
+    """
+    解析結果(複雑度)
+    * サイクロマティック複雑度
+        * 関数・メソッドの平均サイクロマティック複雑度
+    * Halstead複雑度
+        * Halstead Volume, Difficulty, Effort
+    * ネストの深さ
+        * 最大ネスト深度と平均ネスト深度
+    * 認知的複雑度
+        * 制御構造の複雑さを測定
+    * 保守性指数
+        * Maintainability Index
+    """
+
+    cyclomatic_complexity: float
+    halstead_volume: float
+    halstead_difficulty: float
+    halstead_effort: float
+    max_nesting_depth: int
+    avg_nesting_depth: float
+    cognitive_complexity: float
+    maintainability_index: float
+
+
+class Complexity(AbstractAnalysis[ComplexityAnalysisResult]):
+    """解析クラス(複雑度)"""
+
+    def analyze(self, source_code: str) -> ComplexityAnalysisResult:
+        """コード解析"""
+        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),
+            maintainability_index=self.get_maintainability_index(source_code),
+        )
+
+    def get_cyclomatic_complexity(self, source_code: str) -> float:
+        """サイクロマティック複雑度の平均を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            cc_result = cc.cc_visit(source_code)
+            if not cc_result:
+                return 0.0
+
+            total_complexity = sum(item.complexity for item in cc_result)
+            return total_complexity / len(cc_result)
+        except Exception:
+            return 0.0
+
+    def get_halstead_volume(self, source_code: str) -> float:
+        """Halstead Volumeを取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            h_result = metrics.h_visit(source_code)
+            return h_result.total.volume if h_result.total else 0.0
+        except Exception:
+            return 0.0
+
+    def get_halstead_difficulty(self, source_code: str) -> float:
+        """Halstead Difficultyを取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            h_result = metrics.h_visit(source_code)
+            return h_result.total.difficulty if h_result.total else 0.0
+        except Exception:
+            return 0.0
+
+    def get_halstead_effort(self, source_code: str) -> float:
+        """Halstead Effortを取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            h_result = metrics.h_visit(source_code)
+            return h_result.total.effort if h_result.total else 0.0
+        except Exception:
+            return 0.0
+
+    def get_maintainability_index(self, source_code: str) -> float:
+        """保守性指数を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            return metrics.mi_visit(source_code, multi=True)
+        except Exception:
+            return 0.0
+
+    def get_max_nesting_depth(self, source_code: str) -> int:
+        """最大ネスト深度を取得"""
+        if not source_code.strip():
+            return 0
+
+        try:
+            tree = ast.parse(source_code)
+            max_depth = 0
+
+            def calculate_depth(node: ast.AST, current_depth: int = 0) -> int:
+                nonlocal max_depth
+
+                nesting_nodes = (
+                    ast.If,
+                    ast.For,
+                    ast.While,
+                    ast.With,
+                    ast.Try,
+                    ast.FunctionDef,
+                    ast.ClassDef,
+                    ast.AsyncFor,
+                    ast.AsyncWith,
+                )
+
+                if isinstance(node, nesting_nodes):
+                    current_depth += 1
+                    max_depth = max(max_depth, current_depth)
+
+                for child in ast.iter_child_nodes(node):
+                    calculate_depth(child, current_depth)
+
+                return max_depth
+
+            return calculate_depth(tree)
+        except Exception:
+            return 0
+
+    def get_avg_nesting_depth(self, source_code: str) -> float:
+        """平均ネスト深度を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            tree = ast.parse(source_code)
+            depths = []
+
+            def collect_depths(node: ast.AST, current_depth: int = 0) -> None:
+                nesting_nodes = (ast.If, ast.For, ast.While, ast.With, ast.Try)
+
+                if isinstance(node, nesting_nodes):
+                    current_depth += 1
+                    depths.append(current_depth)
+
+                for child in ast.iter_child_nodes(node):
+                    collect_depths(child, current_depth)
+
+            collect_depths(tree)
+            return sum(depths) / len(depths) if depths else 0.0
+        except Exception:
+            return 0.0
+
+    def get_cognitive_complexity(self, source_code: str) -> float:
+        """認知的複雑度を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            tree = ast.parse(source_code)
+            complexity = 0
+
+            def calculate_cognitive_complexity(
+                node: ast.AST, nesting_level: int = 0
+            ) -> int:
+                nonlocal complexity
+
+                if isinstance(node, (ast.If, ast.While, ast.For)):
+                    complexity += 1 + nesting_level
+                elif isinstance(node, ast.Try):
+                    complexity += 1 + nesting_level
+                elif isinstance(node, ast.ExceptHandler):
+                    complexity += 1 + nesting_level
+                elif isinstance(node, ast.BoolOp):
+                    complexity += len(node.values) - 1
+
+                nesting_increment_nodes = (
+                    ast.If,
+                    ast.For,
+                    ast.While,
+                    ast.Try,
+                    ast.FunctionDef,
+                    ast.AsyncFunctionDef,
+                )
+
+                new_nesting_level = nesting_level
+                if isinstance(node, nesting_increment_nodes):
+                    new_nesting_level += 1
+
+                for child in ast.iter_child_nodes(node):
+                    calculate_cognitive_complexity(child, new_nesting_level)
+
+                return complexity
+
+            return float(calculate_cognitive_complexity(tree))
+        except Exception:
+            return 0.0

codinsight-0.0.7/src/code_insight/code_analysis/readability.py

@@ -0,0 +1,272 @@
+import ast
+import math
+import re
+
+from code_insight.code_analysis.abstract import AbstractAnalysis, BaseAnalysisResult
+
+
+class ReadabilityAnalysisResult(BaseAnalysisResult):
+    """
+    解析結果(可読性)
+    * 変数名の長さ
+        * 変数名の平均長
+        * 変数名の最大長
+    * 行の長さ
+        * 行の平均長
+        * 行の最大長
+    * 情報量
+        * Halstead Volume
+        * Halstead Difficulty
+        * Halstead Effort
+    * ネスト深度
+        * 平均ネスト深度
+    * 識別子複雑度
+        * 略語使用率や複雑な命名パターンの割合
+    """
+
+    variable_name_length: float
+    max_variable_name_length: int
+    line_length: float
+    max_line_length: int
+    halstead_volume: float
+    halstead_difficulty: float
+    halstead_effort: float
+    nesting_depth: float
+    identifier_complexity: float
+
+
+class Readability(AbstractAnalysis[ReadabilityAnalysisResult]):
+    """解析クラス(可読性)"""
+
+    def analyze(self, source_code: str) -> ReadabilityAnalysisResult:
+        """コード解析"""
+        return ReadabilityAnalysisResult(
+            variable_name_length=self.get_variable_name_length(source_code),
+            max_variable_name_length=self.get_max_variable_name_length(source_code),
+            line_length=self.get_line_length(source_code),
+            max_line_length=self.get_max_line_length(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),
+            nesting_depth=self.get_nesting_depth(source_code),
+            identifier_complexity=self.get_identifier_complexity(source_code),
+        )
+
+    def parse_source_code(self, source_code: str) -> ast.AST:
+        """ソースコードを解析"""
+        return ast.parse(source_code)
+
+    def get_variable_names(self, source_code: str) -> list[str]:
+        """変数名を抽出"""
+        if not source_code.strip():
+            return []
+
+        tree = self.parse_source_code(source_code)
+        variable_names = []
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
+                variable_names.append(node.id)
+            elif isinstance(node, ast.arg):
+                variable_names.append(node.arg)
+            elif isinstance(node, ast.Attribute) and isinstance(node.ctx, ast.Store):
+                variable_names.append(node.attr)
+
+        return variable_names
+
+    def get_variable_name_length(self, source_code: str) -> float:
+        """変数名の平均長を取得"""
+        variable_names = self.get_variable_names(source_code)
+        if not variable_names:
+            return 0.0
+
+        total_length = sum(len(name) for name in variable_names)
+        return total_length / len(variable_names)
+
+    def get_max_variable_name_length(self, source_code: str) -> int:
+        """変数名の最大長を取得"""
+        variable_names = self.get_variable_names(source_code)
+        if not variable_names:
+            return 0
+
+        return max(len(name) for name in variable_names)
+
+    def get_line_length(self, source_code: str) -> float:
+        """行の平均長を取得"""
+        lines = source_code.splitlines()
+        if not lines:
+            return 0.0
+
+        total_length = sum(len(line) for line in lines)
+        return total_length / len(lines)
+
+    def get_max_line_length(self, source_code: str) -> int:
+        """行の最大長を取得"""
+        lines = source_code.splitlines()
+        if not lines:
+            return 0
+
+        return max(len(line) for line in lines)
+
+    def get_halstead_metrics(self, source_code: str) -> tuple[int, int, int, int]:
+        """Halstead メトリクスの基本値を取得"""
+        if not source_code.strip():
+            return 0, 0, 0, 0
+
+        tree = self.parse_source_code(source_code)
+
+        operators = set()
+        operands = set()
+        operator_count = 0
+        operand_count = 0
+
+        for node in ast.walk(tree):
+            if isinstance(
+                node,
+                (
+                    ast.Add,
+                    ast.Sub,
+                    ast.Mult,
+                    ast.Div,
+                    ast.Mod,
+                    ast.Pow,
+                    ast.LShift,
+                    ast.RShift,
+                    ast.BitOr,
+                    ast.BitXor,
+                    ast.BitAnd,
+                    ast.FloorDiv,
+                ),
+            ):
+                operators.add(type(node).__name__)
+                operator_count += 1
+            elif isinstance(
+                node,
+                (
+                    ast.And,
+                    ast.Or,
+                    ast.Not,
+                    ast.Eq,
+                    ast.NotEq,
+                    ast.Lt,
+                    ast.LtE,
+                    ast.Gt,
+                    ast.GtE,
+                    ast.Is,
+                    ast.IsNot,
+                    ast.In,
+                    ast.NotIn,
+                ),
+            ):
+                operators.add(type(node).__name__)
+                operator_count += 1
+            elif isinstance(
+                node,
+                (
+                    ast.If,
+                    ast.For,
+                    ast.While,
+                    ast.Try,
+                    ast.With,
+                    ast.FunctionDef,
+                    ast.ClassDef,
+                    ast.Return,
+                    ast.Assign,
+                    ast.AugAssign,
+                ),
+            ):
+                operators.add(type(node).__name__)
+                operator_count += 1
+            elif isinstance(node, ast.Name):
+                operands.add(node.id)
+                operand_count += 1
+            elif isinstance(node, ast.Constant):
+                operands.add(str(node.value))
+                operand_count += 1
+
+        n1 = len(operators)
+        n2 = len(operands)
+        N1 = operator_count
+        N2 = operand_count
+
+        return n1, n2, N1, N2
+
+    def get_halstead_volume(self, source_code: str) -> float:
+        """Halstead Volume を計算"""
+        n1, n2, N1, N2 = self.get_halstead_metrics(source_code)
+
+        if n1 + n2 == 0:
+            return 0.0
+
+        N = N1 + N2
+        n = n1 + n2
+
+        return N * math.log2(n) if n > 0 else 0.0
+
+    def get_halstead_difficulty(self, source_code: str) -> float:
+        """Halstead Difficulty を計算"""
+        n1, n2, N1, N2 = self.get_halstead_metrics(source_code)
+
+        if n2 == 0:
+            return 0.0
+
+        return (n1 / 2) * (N2 / n2)
+
+    def get_halstead_effort(self, source_code: str) -> float:
+        """Halstead Effort を計算"""
+        volume = self.get_halstead_volume(source_code)
+        difficulty = self.get_halstead_difficulty(source_code)
+
+        return volume * difficulty
+
+    def get_nesting_depth(self, source_code: str) -> float:
+        """平均ネスト深度を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        tree = self.parse_source_code(source_code)
+        depths = []
+
+        def calculate_depth(node: ast.AST, current_depth: int = 0) -> None:
+            if isinstance(
+                node,
+                (
+                    ast.If,
+                    ast.For,
+                    ast.While,
+                    ast.Try,
+                    ast.With,
+                    ast.FunctionDef,
+                    ast.ClassDef,
+                ),
+            ):
+                depths.append(current_depth)
+                current_depth += 1
+
+            for child in ast.iter_child_nodes(node):
+                calculate_depth(child, current_depth)
+
+        calculate_depth(tree)
+
+        if not depths:
+            return 0.0
+
+        return sum(depths) / len(depths)
+
+    def get_identifier_complexity(self, source_code: str) -> float:
+        """識別子複雑度を取得"""
+        variable_names = self.get_variable_names(source_code)
+        if not variable_names:
+            return 0.0
+
+        complex_count = 0
+
+        for name in variable_names:
+            if len(name) <= 2:
+                complex_count += 1
+            elif re.search(r"[A-Z]{2,}", name):
+                complex_count += 1
+            elif len(re.findall(r"[aeiouAEIOU]", name)) / len(name) < 0.2:
+                complex_count += 1
+
+        return complex_count / len(variable_names)

codinsight-0.0.7/src/code_insight/code_analysis/redundancy.py

@@ -0,0 +1,220 @@
+import ast
+import hashlib
+from collections import defaultdict
+from typing import Any, Dict, List, Set
+
+from radon.complexity import cc_visit
+from radon.metrics import mi_visit
+
+from code_insight.code_analysis.abstract import AbstractAnalysis, BaseAnalysisResult
+
+
+class RedundancyAnalysisResult(BaseAnalysisResult):
+    """
+    解析結果(冗長度)
+    * 重複コード割合
+        * 構造的に類似した関数の割合
+    * 未使用コード割合
+        * 定義されているが呼び出されていない関数・クラスの割合
+    * 長大関数割合
+        * 50行以上または循環的複雑度10以上の関数の割合
+    * 循環的複雑度
+        * 関数の平均循環的複雑度
+    * 保守性指数
+        * 関数の平均保守性指数
+    """
+
+    duplicate_code_rate: float
+    unused_code_rate: float
+    long_function_rate: float
+    cyclomatic_complexity: float
+    maintainability_index: float
+
+
+class Redundancy(AbstractAnalysis[RedundancyAnalysisResult]):
+    """解析クラス(冗長度)"""
+
+    def analyze(self, source_code: str) -> RedundancyAnalysisResult:
+        """コード解析"""
+        return RedundancyAnalysisResult(
+            duplicate_code_rate=self.get_duplicate_code_rate(source_code),
+            unused_code_rate=self.get_unused_code_rate(source_code),
+            long_function_rate=self.get_long_function_rate(source_code),
+            cyclomatic_complexity=self.get_cyclomatic_complexity(source_code),
+            maintainability_index=self.get_maintainability_index(source_code),
+        )
+
+    def parse_source_code(self, source_code: str) -> ast.AST:
+        """ソースコードを解析"""
+        return ast.parse(source_code)
+
+    def get_duplicate_code_rate(self, source_code: str) -> float:
+        """重複コード割合を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        tree = self.parse_source_code(source_code)
+        function_hashes: Dict[str, List[str]] = defaultdict(list)
+        total_functions = 0
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                total_functions += 1
+                func_hash = self._get_function_structure_hash(node)
+                function_hashes[func_hash].append(node.name)
+
+        if total_functions == 0:
+            return 0.0
+
+        duplicate_functions = sum(
+            len(functions) - 1
+            for functions in function_hashes.values()
+            if len(functions) > 1
+        )
+
+        return duplicate_functions / total_functions
+
+    def get_unused_code_rate(self, source_code: str) -> float:
+        """未使用コード割合を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        tree = self.parse_source_code(source_code)
+        defined_names: Set[str] = set()
+        called_names: Set[str] = set()
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                if node.name not in ["main", "__init__", "__main__"]:
+                    defined_names.add(node.name)
+            elif isinstance(node, ast.ClassDef):
+                defined_names.add(node.name)
+            elif isinstance(node, ast.Call):
+                if isinstance(node.func, ast.Name):
+                    called_names.add(node.func.id)
+                elif isinstance(node.func, ast.Attribute):
+                    called_names.add(node.func.attr)
+
+        if not defined_names:
+            return 0.0
+
+        unused_names = defined_names - called_names
+        return len(unused_names) / len(defined_names)
+
+    def get_long_function_rate(self, source_code: str) -> float:
+        """長大関数割合を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        tree = self.parse_source_code(source_code)
+        long_functions = 0
+        total_functions = 0
+
+        try:
+            complexity_results = cc_visit(source_code)
+            complexity_map = {
+                result.name: result.complexity for result in complexity_results
+            }
+        except Exception:
+            complexity_map = {}
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                total_functions += 1
+
+                func_lines = self._count_function_lines(node, source_code)
+                func_complexity = complexity_map.get(node.name, 1)
+
+                if func_lines >= 50 or func_complexity >= 10:
+                    long_functions += 1
+
+        if total_functions == 0:
+            return 0.0
+
+        return long_functions / total_functions
+
+    def get_cyclomatic_complexity(self, source_code: str) -> float:
+        """循環的複雑度の平均を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            complexity_results = cc_visit(source_code)
+            if not complexity_results:
+                return 0.0
+
+            total_complexity = sum(result.complexity for result in complexity_results)
+            return total_complexity / len(complexity_results)
+        except Exception:
+            return 0.0
+
+    def get_maintainability_index(self, source_code: str) -> float:
+        """保守性指数の平均を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            mi_results: list[Any] = mi_visit(
+                source_code, multi=True
+            )  # pyright: ignore[reportAssignmentType]
+            if not mi_results:
+                return 0.0
+
+            total_mi = sum(result.mi for result in mi_results)
+            return total_mi / len(mi_results)
+        except Exception:
+            return 0.0
+
+    def _get_function_structure_hash(self, func_node: ast.FunctionDef) -> str:
+        """関数の構造的ハッシュを取得"""
+        structure_elements = []
+
+        for node in ast.walk(func_node):
+            if isinstance(node, (ast.If, ast.For, ast.While, ast.Try, ast.With)):
+                structure_elements.append(type(node).__name__)
+            elif isinstance(node, ast.Return):
+                if isinstance(node.value, ast.Constant):
+                    node_value = node.value.value
+                    if isinstance(node_value, bytes):
+                        node_value = node_value.decode()
+                    structure_elements.append(
+                        f"return_const_{type(node.value.value).__name__}_"
+                        f"{node_value}"
+                    )
+                elif isinstance(node.value, ast.BinOp):
+                    structure_elements.append(
+                        f"return_binop_{type(node.value.op).__name__}"
+                    )
+                else:
+                    structure_elements.append("return_other")
+            elif isinstance(node, ast.Assign):
+                structure_elements.append("assign")
+            elif isinstance(node, ast.BinOp):
+                structure_elements.append(f"binop_{type(node.op).__name__}")
+
+        arg_count = len(func_node.args.args)
+        structure_elements.append(f"args_{arg_count}")
+
+        if len(structure_elements) < 3:
+            structure_elements.append(f"simple_{len(func_node.body)}")
+
+        structure_str = "_".join(structure_elements)
+        return hashlib.md5(structure_str.encode(), usedforsecurity=False).hexdigest()
+
+    def _count_function_lines(
+        self, func_node: ast.FunctionDef, source_code: str
+    ) -> int:
+        """関数の行数をカウント"""
+        if hasattr(func_node, "end_lineno") and func_node.end_lineno:
+            return func_node.end_lineno - func_node.lineno + 1
+
+        lines = source_code.splitlines()
+        if func_node.lineno <= len(lines):
+            func_start = func_node.lineno - 1
+            for i in range(func_start + 1, len(lines)):
+                line = lines[i].strip()
+                if line and not line.startswith(" ") and not line.startswith("\t"):
+                    return i - func_start
+            return len(lines) - func_start
+
+        return 1

{codinsight-0.0.6 → codinsight-0.0.7}/src/code_insight/core.py

@@ -2,6 +2,10 @@ from enum import StrEnum, auto
 from typing import Any, Type
 
 from code_insight.code_analysis.abstract import AbstractAnalysis, BaseAnalysisResult
+from code_insight.code_analysis.algorithm import Algorithm
+from code_insight.code_analysis.complexity import Complexity
+from code_insight.code_analysis.readability import Readability
+from code_insight.code_analysis.redundancy import Redundancy
 from code_insight.code_analysis.struct import Struct
 from code_insight.code_analysis.style import Style
 
@@ -11,6 +15,7 @@ class CodeAnalysisType(StrEnum):
     コード解析タイプ
     * スタイル
     * 構造
+    * アルゴリズム
     * 複雑度
     * 冗長度
     * 可読性
@@ -19,6 +24,10 @@ class CodeAnalysisType(StrEnum):
 
     STYLE = auto()
     STRUCT = auto()
+    READABILITY = auto()
+    REDUNDANCY = auto()
+    ALGORITHM = auto()
+    COMPLEXITY = auto()
 
     @staticmethod
     def get_code_analysis_class(type: str) -> AbstractAnalysis[Any]:
@@ -27,6 +36,14 @@ class CodeAnalysisType(StrEnum):
             return Style()
         elif type == CodeAnalysisType.STRUCT:
             return Struct()
+        elif type == CodeAnalysisType.READABILITY:
+            return Readability()
+        elif type == CodeAnalysisType.REDUNDANCY:
+            return Redundancy()
+        elif type == CodeAnalysisType.ALGORITHM:
+            return Algorithm()
+        elif type == CodeAnalysisType.COMPLEXITY:
+            return Complexity()
         else:
             raise ValueError(f"Invalid code analysis type: {type}")
 
@@ -36,6 +53,10 @@ class CodeAnalysis:
 
     source_code: str
 
+    def __init__(self, source_code: str) -> None:
+        """コンストラクタ"""
+        self.source_code = source_code
+
     def analyze(
         self, types: list[CodeAnalysisType]
     ) -> dict[CodeAnalysisType, Type[BaseAnalysisResult]]:

codinsight-0.0.7/src/code_insight/trend_analysis/trend_analysis.py

@@ -0,0 +1,104 @@
+from typing import Sequence
+
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.cluster import KMeans
+from sklearn.decomposition import PCA
+
+from code_insight.code_analysis.abstract import BaseAnalysisResult
+
+
+class TrendAnalysis:
+    """コード解析結果分析"""
+
+    code_labels: list[str]
+    code_analysis_list: list[dict[str, float]]
+
+    def __init__(
+        self,
+        code_analysis_results: Sequence[Sequence[BaseAnalysisResult]],
+        code_labels: list[str] | None = None,
+    ) -> None:
+        """コンストラクタ"""
+        self.code_labels = code_labels if code_labels else []
+        self.code_analysis_list: list[dict[str, float]] = [
+            {
+                **{
+                    k: float(v)
+                    for d in [res.model_dump() for res in code_analysis_result]
+                    for k, v in d.items()
+                }
+            }
+            for code_analysis_result in code_analysis_results
+        ]
+
+    def extract_value(self, keys: list[str] | None = None) -> np.ndarray:
+        """
+        任意のkeyの値を抽出
+        * keysが空ならすべてのkeyを抽出する
+        """
+        if not keys:
+            return np.array(
+                [
+                    [value for value in code_analysis.values()]
+                    for code_analysis in self.code_analysis_list
+                ]
+            )
+
+        return np.array(
+            [
+                [code_analysis[key] for key in keys]
+                for code_analysis in self.code_analysis_list
+            ]
+        )
+
+    def compress(self, keys: list[str] | None = None, dimention: int = 2) -> np.ndarray:
+        """任意のkeyの値を圧縮"""
+        pca = PCA(n_components=dimention)
+        return pca.fit_transform(self.extract_value(keys))
+
+    def cluster_values(
+        self, keys: list[str] | None = None, cluster: int = 2
+    ) -> np.ndarray:
+        """任意のkeyの値をクラスタリング"""
+        kmeans = KMeans(n_clusters=cluster)
+        return kmeans.fit_predict(self.extract_value(keys))
+
+    def output_image(
+        self,
+        output_file: str = "clusters.png",
+        keys: list[str] | None = None,
+        cluster: int = 2,
+        dimention: int = 2,
+    ) -> None:
+        """任意のkeyの値を圧縮して画像として出力"""
+        X = self.extract_value(keys)
+
+        # KMeansクラスタリング
+        kmeans = KMeans(n_clusters=cluster, random_state=42)
+        cluster_labels = kmeans.fit_predict(X)
+
+        # 高次元なら2次元に圧縮して可視化 (PCA)
+        if X.shape[1] > 2:
+            X_vis = PCA(n_components=dimention).fit_transform(X)
+        else:
+            X_vis = X
+
+        # プロット
+        plt.figure(figsize=(8, 6))
+        for c in range(cluster):
+            idx = cluster_labels == c
+            plt.scatter(X_vis[idx, 0], X_vis[idx, 1], label=f"Cluster {c}", alpha=0.6)
+            # 各点にラベルを描画
+            for i in np.where(idx)[0]:
+                plt.text(
+                    X_vis[i, 0] + 0.02,
+                    X_vis[i, 1] + 0.02,
+                    self.code_labels[i],
+                    fontsize=8,
+                )
+
+        plt.title("Clustering Result")
+        plt.legend(title="Clusters")
+        plt.savefig(output_file, dpi=150, bbox_inches="tight")
+        plt.close()

{codinsight-0.0.6 → codinsight-0.0.7}/src/codinsight.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codinsight
-Version: 0.0.6
+Version: 0.0.7
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{codinsight-0.0.6 → codinsight-0.0.7}/src/codinsight.egg-info/SOURCES.txt

@@ -5,6 +5,10 @@ src/code_insight/core.py
 src/code_insight/py.typed
 src/code_insight/code_analysis/__init__.py
 src/code_insight/code_analysis/abstract.py
+src/code_insight/code_analysis/algorithm.py
+src/code_insight/code_analysis/complexity.py
+src/code_insight/code_analysis/readability.py
+src/code_insight/code_analysis/redundancy.py
 src/code_insight/code_analysis/struct.py
 src/code_insight/code_analysis/style.py
 src/code_insight/trend_analysis/__init__.py

codinsight-0.0.6/src/code_insight/__init__.py

@@ -1,13 +0,0 @@
-from .code_analysis.struct import Struct, StructAnalysisResult
-from .code_analysis.style import Style, StyleAnalysisResult
-from .core import CodeAnalysis
-from .trend_analysis.trend_analysis import TrendAnalysis
-
-__all__ = [
-    "CodeAnalysis",
-    "Style",
-    "StyleAnalysisResult",
-    "Struct",
-    "StructAnalysisResult",
-    "TrendAnalysis",
-]

codinsight-0.0.6/src/code_insight/trend_analysis/trend_analysis.py

@@ -1,42 +0,0 @@
-from typing import Sequence
-
-import numpy as np
-from sklearn.cluster import KMeans
-from sklearn.decomposition import PCA
-
-from code_insight.code_analysis.abstract import BaseAnalysisResult
-
-
-class TrendAnalysis:
-    """コード解析結果分析"""
-
-    code_analysis: list[dict[str, float]]
-
-    def __init__(
-        self, code_analysis_results: Sequence[Sequence[BaseAnalysisResult]]
-    ) -> None:
-        """コンストラクタ"""
-        self.code_analysis: list[dict[str, float]] = [
-            {
-                **{
-                    k: float(v)
-                    for d in [res.model_dump() for res in code_analysis_result]
-                    for k, v in d.items()
-                }
-            }
-            for code_analysis_result in code_analysis_results
-        ]
-
-    def extract_value(self, keys: list[str]) -> np.ndarray:
-        """任意のkeyの値を抽出"""
-        return np.array([[d[key] for key in keys] for d in self.code_analysis])
-
-    def compress(self, keys: list[str], dimention: int = 2) -> np.ndarray:
-        """任意のkeyの値を圧縮"""
-        pca = PCA(n_components=dimention)
-        return pca.fit_transform(self.extract_value(keys))
-
-    def cluster_values(self, keys: list[str], cluster: int = 2) -> np.ndarray:
-        """任意のkeyの値をクラスタリング"""
-        kmeans = KMeans(n_clusters=cluster)
-        return kmeans.fit_predict(self.extract_value(keys))