diffsense 2.2.12__py3-none-any.whl

core/change.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+from enum import Enum
+
+class ChangeKind(Enum):
+    TYPE_CHANGED = "TYPE_CHANGED"
+    MODIFIER_REMOVED = "MODIFIER_REMOVED"
+    MODIFIER_ADDED = "MODIFIER_ADDED"
+    CALL_REMOVED = "CALL_REMOVED"
+    CALL_ADDED = "CALL_ADDED"
+    FIELD_REMOVED = "FIELD_REMOVED"
+    FIELD_ADDED = "FIELD_ADDED"
+    ANNOTATION_REMOVED = "ANNOTATION_REMOVED"
+    ANNOTATION_ADDED = "ANNOTATION_ADDED"
+    OBJECT_CREATION = "OBJECT_CREATION"
+    # Security-related changes
+    LITERAL_ADDED = "LITERAL_ADDED"  # Hardcoded secrets/passwords
+    LITERAL_REMOVED = "LITERAL_REMOVED"
+    # Fallback/Generic
+    UNKNOWN = "UNKNOWN"
+
+@dataclass
+class Change:
+    kind: ChangeKind
+    file: str
+    symbol: str  # The identifier (variable name, method name, etc.)
+    
+    # Semantic values (not just raw strings if possible, but strings are fine for now)
+    before: Optional[Any] = None
+    after: Optional[Any] = None
+    
+    # Location info
+    line_no: Optional[int] = None
+    
+    # Extra context
+    meta: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self):
+        return {
+            "kind": self.kind.value,
+            "file": self.file,
+            "symbol": self.symbol,
+            "before": self.before,
+            "after": self.after,
+            "meta": self.meta
+        }

core/composer.py

@@ -0,0 +1,93 @@
+from typing import Dict, Any, List
+
+class DecisionComposer:
+    def compose(self, triggered_rules: List[Dict[str, Any]], diff_files: List[str] = None) -> Dict[str, Any]:
+        """
+        Synthesizes triggered rules into a final decision adhering to the Parser Contract.
+        """
+        diff_files = diff_files or []
+        reasons = []
+        details = []
+        impacts_map = {}
+        
+        severity_map = {
+            "critical": 3,
+            "high": 2,
+            "medium": 1,
+            "low": 0
+        }
+        
+        max_score = 0
+        has_blocking_rule = False
+        
+        for rule in triggered_rules:
+            rule_id = rule.get('id', 'unknown')
+            impact_dim = rule.get('impact', 'general')
+            severity = rule.get('severity', 'low')
+            rationale = rule.get('rationale', '')
+            matched_file = rule.get('matched_file', '')
+            precision = rule.get('precision')
+            quality_status = rule.get('quality_status')
+            is_experimental = bool(rule.get("experimental"))
+            is_blocking = rule.get('is_blocking', False)
+            
+            if is_blocking:
+                has_blocking_rule = True
+            
+            reasons.append(rule_id)
+            
+            detail = {
+                "rule_id": rule_id,
+                "severity": severity,
+                "file": matched_file,
+                "rationale": rationale,
+                "impact": impact_dim
+            }
+            if precision is not None:
+                detail["precision"] = precision
+            if quality_status is not None:
+                detail["quality_status"] = quality_status
+            if is_experimental:
+                detail["experimental"] = True
+            details.append(detail)
+            if not is_experimental:
+                current_dim_score = severity_map.get(impacts_map.get(impact_dim, "low"), 0)
+                new_score = severity_map.get(severity, 0)
+                
+                if new_score > current_dim_score:
+                    impacts_map[impact_dim] = severity
+                    
+                if new_score > max_score:
+                    max_score = new_score
+                
+        # Determine Review Level
+        # 只对 CRITICAL 级别触发失败（需要确认），HIGH 及以下仅在评论中报告
+        review_level = "normal"
+        if len(triggered_rules) > 0:
+            # CRITICAL 级别触发 critical review（需要审批/反应）
+            # HIGH 及以下只报告，不阻止 CI
+            if has_blocking_rule or max_score >= 3:
+                review_level = "critical"
+            else:
+                review_level = "low"  # 标记为低风险，仅报告不阻止
+            
+        # Construct Final JSON Contract
+        suggested_action = "auto_merge"
+        if review_level == "critical":
+            suggested_action = "block_pr"
+        elif review_level == "elevated":
+            suggested_action = "manual_review"
+
+        result = {
+            "review_level": review_level,
+            "reasons": reasons,
+            "files": diff_files,
+            "impacts": impacts_map,
+            "details": details,
+            "meta": {
+                "confidence": 1.0, # Placeholder as requested
+                "suggested_action": suggested_action
+            }
+        }
+        
+        return result

core/evaluator.py

@@ -0,0 +1,15 @@
+from typing import Dict, Any, List
+from .rules import RuleEngine
+
+class ImpactEvaluator:
+    def __init__(self, rule_engine: RuleEngine):
+        self.rule_engine = rule_engine
+
+    def evaluate(self, diff_data: Dict[str, Any], ast_signals: List[Any] = None) -> List[Dict[str, Any]]:
+        """
+        Calculates impact by delegating to Rule Engine.
+        Returns a list of triggered rule objects.
+        """
+        ast_signals = ast_signals or []
+        
+        return self.rule_engine.evaluate(diff_data, ast_signals)

core/ignore_manager.py

@@ -0,0 +1,71 @@
+import os
+import yaml
+import fnmatch
+from typing import List, Dict, Any, Optional
+
+class IgnoreManager:
+    """
+    Manages repository-level ignore configurations.
+    """
+    
+    def __init__(self, repo_root: str = "."):
+        self.repo_root = repo_root
+        self.ignores = [] # List of {rule_pattern, file_patterns}
+        self._load_config()
+
+    def _load_config(self):
+        # Prefer diffsense-ignore.yaml (roadmap standard), then legacy names. Only one is loaded.
+        config_files = ["diffsense-ignore.yaml", ".diffsense.yaml", ".diffsenseignore"]
+        
+        for fname in config_files:
+            path = os.path.join(self.repo_root, fname)
+            if os.path.exists(path):
+                try:
+                    with open(path, 'r', encoding='utf-8') as f:
+                        data = yaml.safe_load(f)
+                        if data and 'ignore' in data:
+                            self._parse_ignores(data['ignore'])
+                            print(f"Loaded ignore config from {fname}")
+                            break
+                except Exception as e:
+                    print(f"Error loading ignore config {fname}: {e}")
+
+    def _parse_ignores(self, ignore_list: List[Dict[str, Any]]):
+        for item in ignore_list:
+            rule = item.get('rule') or item.get('id')
+            files = item.get('files', [])
+            if isinstance(files, str):
+                files = [files]
+                
+            if rule:
+                self.ignores.append({
+                    "rule": rule,
+                    "files": files
+                })
+
+    def is_ignored(self, rule_id: str, file_path: str) -> bool:
+        """
+        Checks if a rule is ignored for a specific file.
+        """
+        for ignore in self.ignores:
+            rule_pattern = ignore["rule"]
+            file_patterns = ignore["files"]
+            
+            # Check Rule Match
+            if not fnmatch.fnmatch(rule_id, rule_pattern):
+                continue
+                
+            # If no file patterns, it applies globally (to all files)
+            if not file_patterns:
+                return True
+                
+            # Check File Match
+            for fp in file_patterns:
+                # Normalize paths for matching
+                # file_path might be relative or absolute. Pattern is usually relative.
+                # Let's assume file_path is relative to repo root or just basename?
+                # Usually DiffSense uses relative paths in report.
+                if fnmatch.fnmatch(file_path, fp):
+                    return True
+                    
+        return False

core/knowledge.py

@@ -0,0 +1,77 @@
+from typing import Set
+
+# Layer 1: Knowledge Base / TypeTags
+
+# P0: Thread Safety Types
+THREAD_SAFE_TYPES: Set[str] = {
+    "ConcurrentHashMap",
+    "AtomicInteger",
+    "AtomicLong",
+    "AtomicBoolean",
+    "LongAdder",
+    "DoubleAdder",
+    "BlockingQueue",
+    "ArrayBlockingQueue",
+    "LinkedBlockingQueue",
+    "PriorityBlockingQueue",
+    "DelayQueue",
+    "SynchronousQueue",
+    "LinkedTransferQueue",
+    "LinkedBlockingDeque",
+    "CopyOnWriteArrayList",
+    "CopyOnWriteArraySet",
+    "ConcurrentLinkedQueue",
+    "ConcurrentLinkedDeque",
+    "ConcurrentSkipListMap",
+    "ConcurrentSkipListSet",
+    "ReentrantLock",
+    "ReentrantReadWriteLock",
+    "StampedLock",
+    "Semaphore",
+    "CountDownLatch",
+    "CyclicBarrier",
+    "Exchanger",
+    "Phaser",
+    "StringBuffer", # Legacy but thread-safe
+    "Hashtable",    # Legacy but thread-safe
+    "Vector"        # Legacy but thread-safe
+}
+
+# P0: Lock Types (Subset of Thread Safe, but specific for locking semantics)
+LOCK_TYPES: Set[str] = {
+    "Lock",
+    "ReentrantLock",
+    "ReadWriteLock",
+    "ReentrantReadWriteLock",
+    "StampedLock"
+}
+
+# P1: Resource Types (Need closing)
+RESOURCE_TYPES: Set[str] = {
+    "InputStream",
+    "OutputStream",
+    "Reader",
+    "Writer",
+    "Connection",
+    "Statement",
+    "ResultSet",
+    "Socket",
+    "ServerSocket",
+    "Channel",
+    "Selector",
+    "FileLock"
+}
+
+def is_thread_safe(type_name: str) -> bool:
+    """Check if a type is known to be thread-safe."""
+    # Simple name match for now. 
+    # In a real system, we'd handle full qualified names and inheritance.
+    if not type_name:
+        return False
+    # Handle generics like ConcurrentHashMap<K,V> -> ConcurrentHashMap
+    base_name = type_name.split('<')[0].strip()
+    return base_name in THREAD_SAFE_TYPES
+
+def is_lock_type(type_name: str) -> bool:
+    base_name = type_name.split('<')[0].strip()
+    return base_name in LOCK_TYPES

core/parser.py

@@ -0,0 +1,181 @@
+import re
+import os
+import json
+import time
+import hashlib
+from typing import List, Dict, Any, Optional
+from . import CACHE_VERSION
+from . import get_cache_max_age_seconds
+
+class DiffParser:
+    def __init__(self, cache_dir: Optional[str] = None):
+        self.cache_dir = cache_dir or self._resolve_cache_dir()
+        self.metrics = {"hits": 0, "misses": 0, "saved_ms": 0}
+
+    def _resolve_cache_dir(self) -> str:
+        base_dir = os.environ.get("DIFFSENSE_CACHE_DIR")
+        if not base_dir:
+            base_dir = os.path.join(os.path.expanduser("~"), ".diffsense", "cache")
+        return os.path.join(base_dir, CACHE_VERSION, "diff")
+
+    def _cache_key(self, diff_content: str) -> str:
+        digest = hashlib.sha1(diff_content.encode("utf-8", errors="ignore")).hexdigest()
+        return digest
+
+    def _cache_path(self, cache_key: str) -> str:
+        return os.path.join(self.cache_dir, f"{cache_key}.json")
+
+    def _load_cache(self, cache_key: str) -> Optional[Dict[str, Any]]:
+        path = self._cache_path(cache_key)
+        if not os.path.exists(path):
+            return None
+        max_age = get_cache_max_age_seconds()
+        if max_age > 0:
+            try:
+                mtime = os.path.getmtime(path)
+                if (time.time() - mtime) > max_age:
+                    try:
+                        os.remove(path)
+                    except OSError:
+                        pass
+                    return None
+            except OSError:
+                return None
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return None
+
+    def _save_cache(self, cache_key: str, data: Dict[str, Any]) -> None:
+        os.makedirs(self.cache_dir, exist_ok=True)
+        path = self._cache_path(cache_key)
+        tmp_path = f"{path}.{os.getpid()}.tmp"
+        try:
+            with open(tmp_path, "w", encoding="utf-8") as f:
+                json.dump(data, f)
+            # Atomic rename (replace existing if any)
+            os.replace(tmp_path, path)
+        except Exception:
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+            pass
+
+    def parse(self, diff_content: str) -> Dict[str, Any]:
+        """
+        Parses a unified diff string and returns a structured object.
+        """
+        import time
+        start_time = time.time()
+        
+        files = []
+        new_files = []
+        stats = {"add": 0, "del": 0}
+        file_patches = []
+        
+        cache_key = self._cache_key(diff_content)
+        cached = self._load_cache(cache_key)
+        if cached:
+            self.metrics["hits"] += 1
+            return cached
+
+        self.metrics["misses"] += 1
+
+        # Check if content looks like JSON
+        if diff_content.strip().startswith('{') or diff_content.strip().startswith('['):
+            print("Warning: Diff content looks like JSON. Parser expects Unified Diff format.")
+            result = {"files": [], "new_files": [], "file_patches": [], "stats": stats, "change_types": [], "raw_diff": diff_content}
+            self._save_cache(cache_key, result)
+            return result
+
+        lines = diff_content.splitlines()
+        current_file = None
+        current_patch_lines = []
+        is_new_file = False
+        
+        for line in lines:
+            # Check for new file header
+            if line.startswith("diff --git"):
+                # Save previous patch if exists
+                if current_file and current_patch_lines:
+                    file_patches.append({
+                        "file": current_file,
+                        "patch": "\n".join(current_patch_lines),
+                        "is_new": is_new_file
+                    })
+                    if is_new_file:
+                        new_files.append(current_file)
+                
+                # Reset for new file
+                current_file = None
+                current_patch_lines = []
+                is_new_file = False
+            
+            # Capture filename from --- or +++
+            if line.startswith("--- "):
+                path = line[4:].strip()
+                if path == "/dev/null":
+                    is_new_file = True
+                else:
+                    if path.startswith("a/"):
+                        path = path[2:]
+                    if current_file is None:
+                        current_file = path
+
+            if line.startswith("+++ "):
+                path = line[4:].strip()
+                if path != "/dev/null":
+                    if path.startswith("b/"):
+                        path = path[2:]
+                    current_file = path
+                
+                if current_file and current_file not in files:
+                    files.append(current_file)
+
+            # Accumulate patch lines
+            # We include headers in the patch content for context
+            current_patch_lines.append(line)
+
+            # Stats
+            if line.startswith('+') and not line.startswith('+++'):
+                stats["add"] += 1
+            elif line.startswith('-') and not line.startswith('---'):
+                stats["del"] += 1
+
+        # Add the last patch
+        if current_file and current_patch_lines:
+            file_patches.append({
+                "file": current_file,
+                "patch": "\n".join(current_patch_lines),
+                "is_new": is_new_file
+            })
+            if is_new_file:
+                new_files.append(current_file)
+
+        # Determine change types
+        change_types = set()
+        for f in files:
+            if f.endswith('.json') or f.endswith('.yaml') or f.endswith('.yml'):
+                change_types.add("config")
+            elif f.endswith('.ts') or f.endswith('.py') or f.endswith('.go') or f.endswith('.java'):
+                change_types.add("logic")
+            elif f.endswith('.md') or f.endswith('.txt'):
+                change_types.add("doc")
+            else:
+                change_types.add("other")
+
+        result = {
+            "files": files,
+            "new_files": new_files,
+            "file_patches": file_patches,
+            "stats": stats,
+            "change_types": list(change_types),
+            "raw_diff": diff_content
+        }
+        
+        # Track how much time this parse took to estimate future savings
+        duration_ms = (time.time() - start_time) * 1000
+        self.metrics["saved_ms"] = duration_ms # Proxy for saved time on hit
+        
+        self._save_cache(cache_key, result)
+        return result

core/parser_manager.py

@@ -0,0 +1,104 @@
+"""
+Multi-language Parser Manager for DiffSense
+Manages language-specific parsers and provides unified AST signal extraction interface.
+"""
+
+import os
+import importlib
+from typing import Dict, List, Any, Optional, Set
+from core.rule_base import Rule
+
+class ParserManager:
+    """
+    Manages multiple language parsers and provides unified interface for AST signal extraction.
+    Parsers are loaded dynamically based on available language modules.
+    """
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        self.config = config or {}
+        self.parsers: Dict[str, Any] = {}
+        self.supported_languages: Set[str] = set()
+        self._load_parsers()
+    
+    def _load_parsers(self):
+        """Load all available language parsers from diffsense.parsers package."""
+        parser_dir = os.path.join(os.path.dirname(__file__), '..', 'parsers')
+        if not os.path.exists(parser_dir):
+            return
+        
+        # Look for language-specific parser modules
+        for item in os.listdir(parser_dir):
+            if item.startswith('__') or not item.endswith('.py'):
+                continue
+            
+            module_name = item[:-3]  # Remove .py extension
+            try:
+                # Try to import the parser module
+                parser_module = importlib.import_module(f'diffsense.parsers.{module_name}')
+                
+                # Check if it has a get_parser function
+                if hasattr(parser_module, 'get_parser'):
+                    parser_instance = parser_module.get_parser(self.config)
+                    language = getattr(parser_instance, 'language', module_name)
+                    
+                    self.parsers[language] = parser_instance
+                    self.supported_languages.add(language)
+                    
+            except (ImportError, AttributeError) as e:
+                # Skip modules that don't conform to parser interface
+                continue
+    
+    def extract_signals(self, file_path: str, file_content: str, language: Optional[str] = None) -> List[Any]:
+        """
+        Extract AST signals from a file using the appropriate language parser.
+        
+        Args:
+            file_path: Path to the source file
+            file_content: Content of the source file
+            language: Optional explicit language hint
+            
+        Returns:
+            List of AST signals extracted from the file
+        """
+        # Determine language if not provided
+        if language is None:
+            language = self._detect_language(file_path)
+        
+        # Use appropriate parser if available
+        if language in self.parsers:
+            try:
+                return self.parsers[language].extract_signals(file_path, file_content)
+            except Exception as e:
+                # Log error but don't crash - return empty signals
+                return []
+        
+        # Fallback: return empty signals for unsupported languages
+        return []
+    
+    def _detect_language(self, file_path: str) -> str:
+        """Detect programming language from file extension."""
+        extension_map = {
+            '.java': 'java',
+            '.go': 'go', 
+            '.py': 'python',
+            '.js': 'javascript',
+            '.ts': 'typescript',
+            '.cpp': 'cpp',
+            '.c': 'c',
+            '.cs': 'csharp',
+            '.rb': 'ruby',
+            '.php': 'php',
+            '.scala': 'scala',
+            '.kt': 'kotlin'
+        }
+        
+        _, ext = os.path.splitext(file_path.lower())
+        return extension_map.get(ext, 'unknown')
+    
+    def get_supported_languages(self) -> Set[str]:
+        """Get set of supported programming languages."""
+        return self.supported_languages.copy()
+    
+    def is_language_supported(self, language: str) -> bool:
+        """Check if a language is supported by available parsers."""
+        return language in self.supported_languages