codinsight 0.2.0__tar.gz → 0.3.0__tar.gz

{codinsight-0.2.0 → codinsight-0.3.0}/PKG-INFO

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

{codinsight-0.2.0 → codinsight-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codinsight"
-version = "0.2.0"
+version = "0.3.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -35,6 +35,22 @@ addopts = "--exclude=tests"
 packages = ["src/code_insight"]
 include = ["src/code_insight/py.typed"]
 
+[tool.ruff]
+line-length = 88
+include = ["codinsight/**/*.py"]
+
+[tool.ruff.lint]
+select = ["F", "E", "I", "B"]
+
+[tool.ruff.lint.isort]
+# black profileと同等の設定
+split-on-trailing-comma = true
+combine-as-imports = true
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["src"]

{codinsight-0.2.0 → codinsight-0.3.0}/src/code_insight/code_analysis/redundancy.py

@@ -286,8 +286,7 @@ class Redundancy(AbstractAnalysis[RedundancyAnalysisResult, RedundancyAnalysisCo
                     if isinstance(node_value, bytes):
                         node_value = node_value.decode()
                     structure_elements.append(
-                        f"return_const_{type(node.value.value).__name__}_"
-                        f"{node_value}"
+                        f"return_const_{type(node.value.value).__name__}_{node_value}"
                     )
                 elif isinstance(node.value, ast.BinOp):
                     structure_elements.append(

codinsight-0.3.0/src/code_insight/code_analysis/security.py

@@ -0,0 +1,327 @@
+import ast
+import re
+from typing import List, Set
+
+from code_insight.code_analysis.abstract import (
+    AbstractAnalysis,
+    BaseAnalysisConfig,
+    BaseAnalysisResult,
+)
+
+
+class SecurityAnalysisConfig(BaseAnalysisConfig):
+    """
+    セキュリティ解析設定
+
+    Attributes
+    ----------
+    check_hardcoded_secrets : bool
+        ハードコードされた秘密情報をチェックするか, by default True
+    check_dangerous_functions : bool
+        危険な関数の使用をチェックするか, by default True
+    check_sql_injection : bool
+        SQLインジェクション脆弱性をチェックするか, by default True
+    secret_patterns : List[str]
+        秘密情報検出パターン, by default 標準パターン
+    """
+
+    check_hardcoded_secrets: bool = True
+    check_dangerous_functions: bool = True
+    check_sql_injection: bool = True
+    secret_patterns: List[str] = [
+        r"password\s*=\s*['\"][^'\"]{3,}['\"]",
+        r"api_key\s*=\s*['\"][^'\"]{10,}['\"]",
+        r"secret\s*=\s*['\"][^'\"]{8,}['\"]",
+        r"token\s*=\s*['\"][^'\"]{10,}['\"]",
+        r"key\s*=\s*['\"][^'\"]{8,}['\"]",
+    ]
+
+
+class SecurityAnalysisResult(BaseAnalysisResult):
+    """
+    解析結果(セキュリティ)
+
+    Attributes
+    ----------
+    hardcoded_secrets_count : int
+        ハードコードされた秘密情報の数
+    dangerous_function_count : int
+        危険な関数の使用数
+    sql_injection_risk_count : int
+        SQLインジェクション脆弱性の可能性がある箇所の数
+    input_validation_missing_count : int
+        入力検証不備の数
+    security_score : float
+        セキュリティスコア（0.0-1.0、高いほど安全）
+    """
+
+    hardcoded_secrets_count: int
+    dangerous_function_count: int
+    sql_injection_risk_count: int
+    input_validation_missing_count: int
+    security_score: float
+
+
+class Security(AbstractAnalysis[SecurityAnalysisResult, SecurityAnalysisConfig]):
+    """
+    解析クラス(セキュリティ)
+
+    Notes
+    -----
+    コードのセキュリティ脆弱性を多角的に解析するクラス
+    """
+
+    def __init__(self, config: SecurityAnalysisConfig | None = None) -> None:
+        """
+        コンストラクタ
+
+        Parameters
+        ----------
+        config : SecurityAnalysisConfig | None, optional
+            セキュリティ解析設定, by default None
+        """
+        super().__init__(config)
+
+    def get_default_config(self) -> SecurityAnalysisConfig:
+        """
+        デフォルト設定を取得
+
+        Returns
+        -------
+        SecurityAnalysisConfig
+            デフォルトのセキュリティ解析設定
+        """
+        return SecurityAnalysisConfig()
+
+    def analyze(self, source_code: str) -> SecurityAnalysisResult:
+        """
+        コード解析
+
+        Parameters
+        ----------
+        source_code : str
+            解析対象のソースコード
+
+        Returns
+        -------
+        SecurityAnalysisResult
+            セキュリティ解析結果
+        """
+        if not self.config.enabled:
+            return SecurityAnalysisResult(
+                hardcoded_secrets_count=0,
+                dangerous_function_count=0,
+                sql_injection_risk_count=0,
+                input_validation_missing_count=0,
+                security_score=1.0,
+            )
+
+        tree = self.parse_source_code(source_code)
+
+        hardcoded_secrets = self.get_hardcoded_secrets_count(source_code, tree)
+        dangerous_functions = self.get_dangerous_function_count(source_code, tree)
+        sql_injection_risks = self.get_sql_injection_risk_count(source_code, tree)
+        input_validation_missing = self.get_input_validation_missing_count(source_code, tree)
+
+        security_score = self.calculate_security_score(
+            hardcoded_secrets, dangerous_functions, sql_injection_risks, input_validation_missing
+        )
+
+        return SecurityAnalysisResult(
+            hardcoded_secrets_count=hardcoded_secrets,
+            dangerous_function_count=dangerous_functions,
+            sql_injection_risk_count=sql_injection_risks,
+            input_validation_missing_count=input_validation_missing,
+            security_score=security_score,
+        )
+
+    def parse_source_code(self, source_code: str) -> ast.AST:
+        """
+        ソースコードを解析
+
+        Parameters
+        ----------
+        source_code : str
+            解析対象のソースコード
+
+        Returns
+        -------
+        ast.AST
+            解析済みのAST
+        """
+        return ast.parse(source_code)
+
+    def get_hardcoded_secrets_count(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> int:
+        """
+        ハードコードされた秘密情報の数を取得
+
+        Parameters
+        ----------
+        source_code : str
+            解析対象のソースコード
+        tree : ast.AST | None, optional
+            解析済みのAST, by default None
+
+        Returns
+        -------
+        int
+            ハードコードされた秘密情報の数
+        """
+        if not self.config.check_hardcoded_secrets:
+            return 0
+
+        count = 0
+        source_lower = source_code.lower()
+
+        for pattern in self.config.secret_patterns:
+            matches = re.findall(pattern, source_lower, re.IGNORECASE)
+            count += len(matches)
+
+        return count
+
+    def get_dangerous_function_count(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> int:
+        """
+        危険な関数の使用数を取得
+
+        Parameters
+        ----------
+        source_code : str
+            解析対象のソースコード
+        tree : ast.AST | None, optional
+            解析済みのAST, by default None
+
+        Returns
+        -------
+        int
+            危険な関数の使用数
+        """
+        if not self.config.check_dangerous_functions:
+            return 0
+
+        tree = tree or self.parse_source_code(source_code)
+        dangerous_functions = {"eval", "exec", "compile", "__import__"}
+        count = 0
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                if isinstance(node.func, ast.Name) and node.func.id in dangerous_functions:
+                    count += 1
+
+        return count
+
+    def get_sql_injection_risk_count(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> int:
+        """
+        SQLインジェクション脆弱性の可能性がある箇所の数を取得
+
+        Parameters
+        ----------
+        source_code : str
+            解析対象のソースコード
+        tree : ast.AST | None, optional
+            解析済みのAST, by default None
+
+        Returns
+        -------
+        int
+            SQLインジェクション脆弱性の可能性がある箇所の数
+        """
+        if not self.config.check_sql_injection:
+            return 0
+
+        tree = tree or self.parse_source_code(source_code)
+        count = 0
+
+        sql_patterns = [
+            r"select\s+.*\s+from\s+.*\+",
+            r"insert\s+into\s+.*\+",
+            r"update\s+.*\s+set\s+.*\+",
+            r"delete\s+from\s+.*\+",
+        ]
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+                if isinstance(node.left, ast.Constant) and isinstance(node.left.value, str):
+                    sql_text = node.left.value.lower()
+                    for pattern in sql_patterns:
+                        if re.search(pattern, sql_text):
+                            count += 1
+                            break
+
+        return count
+
+    def get_input_validation_missing_count(
+        self, source_code: str, tree: ast.AST | None = None
+    ) -> int:
+        """
+        入力検証不備の数を取得
+
+        Parameters
+        ----------
+        source_code : str
+            解析対象のソースコード
+        tree : ast.AST | None, optional
+            解析済みのAST, by default None
+
+        Returns
+        -------
+        int
+            入力検証不備の数
+        """
+        tree = tree or self.parse_source_code(source_code)
+        count = 0
+        input_functions = {"input", "raw_input"}
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                if isinstance(node.func, ast.Name) and node.func.id in input_functions:
+                    parent_found = False
+                    for parent in ast.walk(tree):
+                        if isinstance(parent, ast.If):
+                            for child in ast.walk(parent):
+                                if child is node:
+                                    parent_found = True
+                                    break
+                    if not parent_found:
+                        count += 1
+
+        return count
+
+    def calculate_security_score(
+        self,
+        hardcoded_secrets: int,
+        dangerous_functions: int,
+        sql_injection_risks: int,
+        input_validation_missing: int,
+    ) -> float:
+        """
+        セキュリティスコアを計算
+
+        Parameters
+        ----------
+        hardcoded_secrets : int
+            ハードコードされた秘密情報の数
+        dangerous_functions : int
+            危険な関数の使用数
+        sql_injection_risks : int
+            SQLインジェクション脆弱性の可能性がある箇所の数
+        input_validation_missing : int
+            入力検証不備の数
+
+        Returns
+        -------
+        float
+            セキュリティスコア（0.0-1.0、高いほど安全）
+        """
+        total_issues = hardcoded_secrets + dangerous_functions + sql_injection_risks + input_validation_missing
+
+        if total_issues == 0:
+            return 1.0
+
+        penalty = min(total_issues * 0.1, 1.0)
+        return max(1.0 - penalty, 0.0)

{codinsight-0.2.0 → codinsight-0.3.0}/src/code_insight/core.py

@@ -1,5 +1,5 @@
 from enum import StrEnum, auto
-from typing import Any, Type
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -16,6 +16,7 @@ from code_insight.code_analysis.readability import (
     ReadabilityAnalysisConfig,
 )
 from code_insight.code_analysis.redundancy import Redundancy, RedundancyAnalysisConfig
+from code_insight.code_analysis.security import Security, SecurityAnalysisConfig
 from code_insight.code_analysis.struct import Struct, StructAnalysisConfig
 from code_insight.code_analysis.style import Style, StyleAnalysisConfig
 
@@ -40,6 +41,8 @@ class AnalysisConfigs(BaseModel):
         複雑度解析設定, by default None
     quality : QualityAnalysisConfig | None
         品質解析設定, by default None
+    security : SecurityAnalysisConfig | None
+        セキュリティ解析設定, by default None
     """
 
     style: StyleAnalysisConfig | None = None
@@ -49,6 +52,7 @@ class AnalysisConfigs(BaseModel):
     algorithm: AlgorithmAnalysisConfig | None = None
     complexity: ComplexityAnalysisConfig | None = None
     quality: QualityAnalysisConfig | None = None
+    security: SecurityAnalysisConfig | None = None
 
 
 class CodeAnalysisType(StrEnum):
@@ -71,6 +75,8 @@ class CodeAnalysisType(StrEnum):
         複雑度解析
     QUALITY : str
         品質解析
+    SECURITY : str
+        セキュリティ解析
     """
 
     STYLE = auto()
@@ -80,6 +86,7 @@ class CodeAnalysisType(StrEnum):
     ALGORITHM = auto()
     COMPLEXITY = auto()
     QUALITY = auto()
+    SECURITY = auto()
 
     @staticmethod
     def get_code_analysis_class(
@@ -119,6 +126,8 @@ class CodeAnalysisType(StrEnum):
             return Complexity(config)  # type: ignore
         elif type == CodeAnalysisType.QUALITY:
             return Quality(config)  # type: ignore
+        elif type == CodeAnalysisType.SECURITY:
+            return Security(config)  # type: ignore
         else:
             raise ValueError(f"Invalid code analysis type: {type}")
 
@@ -156,7 +165,7 @@ class CodeAnalysis:
 
     def analyze(
         self, types: list[CodeAnalysisType]
-    ) -> dict[CodeAnalysisType, Type[BaseAnalysisResult]]:
+    ) -> dict[CodeAnalysisType, BaseAnalysisResult]:
         """
         コード解析
 
@@ -167,10 +176,10 @@ class CodeAnalysis:
 
         Returns
         -------
-        dict[CodeAnalysisType, Type[BaseAnalysisResult]]
+        dict[CodeAnalysisType, BaseAnalysisResult]
             解析結果の辞書
         """
-        result: dict[CodeAnalysisType, Type[BaseAnalysisResult]] = {}
+        result: dict[CodeAnalysisType, BaseAnalysisResult] = {}
         for type in types:
             config = self._get_config_for_type(type)
             result[type] = CodeAnalysisType.get_code_analysis_class(
@@ -205,5 +214,6 @@ class CodeAnalysis:
             CodeAnalysisType.ALGORITHM: self.configs.algorithm,
             CodeAnalysisType.COMPLEXITY: self.configs.complexity,
             CodeAnalysisType.QUALITY: self.configs.quality,
+            CodeAnalysisType.SECURITY: self.configs.security,
         }
         return config_map.get(analysis_type)

{codinsight-0.2.0 → codinsight-0.3.0}/src/code_insight/multi_analysis.py

@@ -1,6 +1,6 @@
 import os
 from pathlib import Path
-from typing import Any, Iterable, cast
+from typing import Iterable
 
 from pydantic import BaseModel
 
@@ -24,7 +24,7 @@ class FileAnalysisResult(BaseModel):
     """
 
     path: str
-    results: dict[str, dict[str, Any]]
+    results: dict[CodeAnalysisType, BaseAnalysisResult]
 
 
 class AggregateStats(BaseModel):
@@ -46,7 +46,7 @@ class AggregateStats(BaseModel):
     total_files: int
     analyzed_files: int
     errors: list[str]
-    by_type_avg: dict[str, dict[str, float]]
+    by_type_avg: dict[CodeAnalysisType, dict[str, float]]
 
 
 class MultiAnalysisResult(BaseModel):
@@ -169,16 +169,15 @@ def analyze_file(
     source_code = path.read_text(encoding="utf-8", errors="ignore")
     analysis = CodeAnalysis(source_code=source_code, configs=configs)
     result_map = analysis.analyze(types)
-    as_dict: dict[str, dict[str, Any]] = {}
+    as_dict: dict[CodeAnalysisType, BaseAnalysisResult] = {}
     for t, model in result_map.items():
-        m = cast(BaseAnalysisResult, model)
-        as_dict[t.name] = m.model_dump()
+        as_dict[t] = model
     return FileAnalysisResult(path=str(path), results=as_dict)
 
 
 def _aggregate_numeric_means(
     files: list[FileAnalysisResult],
-) -> dict[str, dict[str, float]]:
+) -> dict[CodeAnalysisType, dict[str, float]]:
     """
     数値メトリクスの平均値を集約
 
@@ -192,17 +191,17 @@ def _aggregate_numeric_means(
     dict[str, dict[str, float]]
         解析タイプ別の平均値辞書
     """
-    by_type: dict[str, dict[str, list[float]]] = {}
+    by_type: dict[CodeAnalysisType, dict[str, list[float]]] = {}
 
     for fa in files:
         for tname, metrics in fa.results.items():
             if tname not in by_type:
                 by_type[tname] = {}
-            for key, val in metrics.items():
+            for key, val in metrics.model_dump().items():
                 if isinstance(val, (int, float)):
                     by_type[tname].setdefault(key, []).append(float(val))
 
-    avg: dict[str, dict[str, float]] = {}
+    avg: dict[CodeAnalysisType, dict[str, float]] = {}
     for tname, metrics_map in by_type.items():
         avg[tname] = {}
         for key, values in metrics_map.items():

{codinsight-0.2.0 → codinsight-0.3.0}/src/code_insight/trend_analysis/trend_analysis.py

@@ -167,7 +167,7 @@ class TrendAnalysis:
                     X_vis[i, 0] + 0.02,
                     X_vis[i, 1] + 0.02,
                     self.code_labels[i],
-                    fontsize=8,
+                    fontsize=7,
                 )
 
         plt.title("Clustering Result")

{codinsight-0.2.0 → codinsight-0.3.0}/src/codinsight.egg-info/PKG-INFO

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

{codinsight-0.2.0 → codinsight-0.3.0}/src/codinsight.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/code_insight/code_analysis/complexity.py
 src/code_insight/code_analysis/quality.py
 src/code_insight/code_analysis/readability.py
 src/code_insight/code_analysis/redundancy.py
+src/code_insight/code_analysis/security.py
 src/code_insight/code_analysis/struct.py
 src/code_insight/code_analysis/style.py
 src/code_insight/trend_analysis/__init__.py