diffsense 2.2.12__py3-none-any.whl

core/run_config.py

@@ -0,0 +1,85 @@
+"""
+Load run config from repo .diffsense.yaml or diffsense-ignore.yaml.
+Used as defaults for profile, auto_tune, ci_fail_level, cache, scheduler, rule_quality.
+CLI / main / run_audit override these with explicit args when provided.
+Also resolves pro_rules_path (super rules) for formal DiffSense runs.
+"""
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+def _load_yaml(path: str) -> Optional[Dict[str, Any]]:
+    if not os.path.isfile(path):
+        return None
+    try:
+        import yaml
+        with open(path, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+    except Exception:
+        return None
+
+def get_run_config(repo_root: str = ".") -> Dict[str, Any]:
+    """
+    Load run config from repo_root. Prefer .diffsense.yaml, then diffsense-ignore.yaml.
+    Returns dict with keys: profile, auto_tune, ci_fail_level, cache, scheduler, rule_quality.
+    Missing keys are absent (caller uses own defaults).
+    """
+    out: Dict[str, Any] = {}
+    for fname in (".diffsense.yaml", "diffsense-ignore.yaml"):
+        path = os.path.join(repo_root, fname)
+        data = _load_yaml(path)
+        if not data:
+            continue
+        if data.get("profile") is not None:
+            out["profile"] = str(data["profile"]).strip() or None
+        if data.get("auto_tune") is not None:
+            out["auto_tune"] = bool(data["auto_tune"])
+        if data.get("ci_fail_level") is not None:
+            out["ci_fail_level"] = str(data["ci_fail_level"]).strip() or None
+        if data.get("cache") is not None:
+            out["cache"] = bool(data["cache"])
+        if data.get("scheduler") is not None:
+            out["scheduler"] = bool(data["scheduler"])
+        if isinstance(data.get("rule_quality"), dict):
+            out["rule_quality"] = dict(data["rule_quality"])
+        if data.get("pro_rules_path") is not None:
+            out["pro_rules_path"] = str(data["pro_rules_path"]).strip() or None
+        if isinstance(data.get("dependency_versions"), dict):
+            # 用户配置的依赖版本，用于 CVE 规则精确匹配：ecosystem -> package_name -> version
+            # 例如: dependency_versions: { npm: { lodash: "4.17.21" }, maven: { "org.apache.tomcat:tomcat-catalina": "9.0.72" } }
+            out["dependency_versions"] = {k: dict(v) for k, v in data["dependency_versions"].items() if isinstance(v, dict)}
+        break
+    return out
+
+
+def get_pro_rules_path(cwd: Optional[str] = None) -> Optional[str]:
+    """
+    解析 PRO 规则（超级规则）目录路径，供正式 audit/main 加载。
+    优先级: 环境变量 DIFFSENSE_PRO_RULES > 仓库 .diffsense.yaml 的 pro_rules_path >
+            相对 diffsense 包上级的 pro-rules（开发/同仓部署）。
+    仅当路径存在时返回，否则返回 None。
+    """
+    cwd = cwd or os.getcwd()
+    # 1. 环境变量
+    env_path = os.environ.get("DIFFSENSE_PRO_RULES", "").strip()
+    if env_path and os.path.isdir(env_path):
+        return os.path.normpath(env_path)
+    # 2. 仓库配置
+    run_cfg = get_run_config(cwd)
+    cfg_path = run_cfg.get("pro_rules_path")
+    if cfg_path and os.path.isdir(os.path.normpath(cfg_path)):
+        return os.path.normpath(cfg_path)
+    if cfg_path:
+        abs_cfg = os.path.normpath(os.path.join(cwd, cfg_path))
+        if os.path.isdir(abs_cfg):
+            return abs_cfg
+    # 3. 默认：与 diffsense 包同级的 pro-rules（源码/同仓）
+    try:
+        import diffsense
+        base = Path(diffsense.__file__).resolve().parent.parent
+    except Exception:
+        base = Path(__file__).resolve().parent.parent.parent
+    default = base / "pro-rules"
+    if default.is_dir():
+        return str(default)
+    return None

core/semantic_diff.py

@@ -0,0 +1,359 @@
+"""
+Semantic Analysis Engine for DiffSense
+
+Multi-language semantic analysis supporting Java, Go, Python, C++, and JavaScript.
+Uses language-specific parsers and adapters to extract semantic signals.
+"""
+
+from typing import List, Set, Dict, Any, Tuple, Optional
+from sdk.signal import Signal
+
+# Import parsers registry (lazy import to avoid circular dependency)
+def _get_parser_for_file(filename: str):
+    try:
+        from diffsense.parsers.registry import get_parser_for_file
+        return get_parser_for_file(filename)
+    except ImportError:
+        return None
+
+
+class SemanticDiff:
+    """
+    L2 Semantic Analysis Engine (Multi-Language Version).
+    
+    Responsibility: Parse Diff -> Extract Semantic Signals.
+    Does NOT execute rules.
+    
+    Supports: Java, Go, Python, C++, JavaScript
+    """
+    
+    def __init__(self):
+        # Language-specific semantic analysis (currently only Java has deep support)
+        # Other languages use parser-level signals
+        self._language_extensions = {
+            '.java': 'java',
+            '.go': 'go',
+            '.py': 'python',
+            '.pyi': 'python',
+            '.cpp': 'cpp',
+            '.cc': 'cpp',
+            '.cxx': 'cpp',
+            '.h': 'cpp',
+            '.hpp': 'cpp',
+            '.js': 'javascript',
+            '.jsx': 'javascript',
+            '.ts': 'javascript',
+            '.tsx': 'javascript',
+            '.mjs': 'javascript',
+            '.cjs': 'javascript',
+        }
+        
+        # Pagination variables (for Java)
+        self._pagination_vars = {"pageNo", "pageSize", "start", "limit", "offset"}
+        
+        # Critical calls (for Java)
+        self._critical_calls = {"encode", "decode", "validate", "check", "normalize", "sanitize"}
+    
+    def get_language(self, filename: str) -> str:
+        """Detect language from filename extension."""
+        ext = '.' + filename.split('.')[-1] if '.' in filename else ''
+        return self._language_extensions.get(ext, 'unknown')
+    
+    def detect_signals(self, diff_data: Dict[str, Any]) -> List[Signal]:
+        """
+        Main Entry Point: Returns semantic signals for all languages.
+        """
+        signals = []
+        file_patches = diff_data.get('file_patches', [])
+        
+        # Fallback if parser isn't upgraded
+        if not file_patches and 'raw_diff' in diff_data:
+            file_patches = [{'file': 'unknown', 'patch': diff_data['raw_diff']}]
+        
+        # Group files by language
+        files_by_language: Dict[str, List[Dict]] = {}
+        for entry in file_patches:
+            filename = entry.get('file', 'unknown')
+            language = self.get_language(filename)
+            if language not in files_by_language:
+                files_by_language[language] = []
+            files_by_language[language].append(entry)
+        
+        # Analyze each language's files
+        for language, files in files_by_language.items():
+            if language == 'java':
+                # Java: Use existing semantic analysis
+                java_signals = self._detect_java_signals(files)
+                signals.extend(java_signals)
+            elif language != 'unknown':
+                # Other languages: Use parser-level signals
+                parser_signals = self._detect_parser_signals(files, language, diff_data)
+                signals.extend(parser_signals)
+        
+        return signals
+    
+    def _detect_java_signals(self, file_patches: List[Dict]) -> List[Signal]:
+        """
+        Java-specific semantic analysis (deep analysis).
+        """
+        # Import Java-specific modules lazily to avoid issues
+        from javalang.tree import (
+            SynchronizedStatement, MethodInvocation, FieldDeclaration, 
+            MethodDeclaration, LocalVariableDeclaration, VariableDeclarator,
+            ForStatement, WhileStatement, DoStatement
+        )
+        from .change import Change, ChangeKind
+        from .knowledge import is_thread_safe, is_lock_type
+        
+        signals = []
+        
+        # Determine Analysis Tier based on Java file count
+        if len(file_patches) > 30:
+            return [Signal(
+                id="meta.large_refactor",
+                file="meta",
+                action="detected",
+                line=None,
+                meta={"tier": 3, "language": "java"}
+            )]
+        
+        analysis_mode = "deep"
+        if 10 < len(file_patches) <= 30:
+            analysis_mode = "light"
+        
+        for entry in file_patches:
+            filename = entry.get('file', 'unknown')
+            patch_content = entry.get('patch', '')
+            
+            if not filename.endswith('.java'):
+                continue
+            
+            file_changes = self._detect_changes_in_patch(
+                filename, patch_content, mode=analysis_mode
+            )
+            
+            for ch in file_changes:
+                sig = self._convert_change_to_signal(ch)
+                if sig:
+                    signals.append(sig)
+        
+        return signals
+    
+    def _detect_parser_signals(self, file_patches: List[Dict], language: str, diff_data: Dict) -> List[Signal]:
+        """
+        Use language-specific parsers to extract signals for non-Java languages.
+        """
+        signals = []
+        
+        # Get parser for this language
+        parser = None
+        for entry in file_patches:
+            filename = entry.get('file', 'unknown')
+            parser = _get_parser_for_file(filename)
+            if parser:
+                break
+        
+        if not parser:
+            return signals
+        
+        # Get diff context
+        changes_context = []
+        if 'changes' in diff_data:
+            changes_context = diff_data['changes']
+        
+        diff_context = {'changes': changes_context}
+        
+        # Parse each file and extract signals
+        for entry in file_patches:
+            filename = entry.get('file', 'unknown')
+            content = entry.get('content', '')
+            
+            if content:
+                # Parse the file
+                ast_data = parser.parse_file(filename, content)
+                
+                # Extract signals
+                if hasattr(parser, 'extract_signals'):
+                    file_signals = parser.extract_signals(ast_data, diff_context)
+                    for sig_dict in file_signals:
+                        signal = Signal(
+                            id=sig_dict.get('id', 'unknown'),
+                            file=filename,
+                            action=sig_dict.get('action', 'unknown'),
+                            line=sig_dict.get('line'),
+                            meta=sig_dict.get('meta', {})
+                        )
+                        signals.append(signal)
+        
+        return signals
+    
+    def _detect_changes_in_patch(self, filename: str, patch_content: str, mode: str = "deep") -> List[Any]:
+        """
+        Detect changes in a patch (Java-specific implementation).
+        This is the existing logic from the original semantic_diff.py
+        """
+        # Lazy import to avoid circular dependency
+        from javalang import parse as javalang_parse
+        from javalang.tree import (
+            SynchronizedStatement, MethodInvocation, FieldDeclaration,
+            MethodDeclaration, LocalVariableDeclaration, VariableDeclarator,
+            ForStatement, WhileStatement, DoStatement
+        )
+        
+        changes = []
+        added_lines = []
+        removed_lines = []
+        
+        for line in patch_content.splitlines():
+            if line.startswith('+') and not line.startswith('+++'):
+                added_lines.append(line[1:].strip())
+            elif line.startswith('-') and not line.startswith('---'):
+                removed_lines.append(line[1:].strip())
+        
+        # Analyze removed lines
+        if removed_lines:
+            self._analyze_snippet_for_changes(
+                removed_lines, filename, is_added=False, 
+                changes=changes, mode=mode
+            )
+        
+        # Analyze added lines
+        if added_lines:
+            self._analyze_snippet_for_changes(
+                added_lines, filename, is_added=True,
+                changes=changes, mode=mode
+            )
+        
+        return changes
+    
+    def _analyze_snippet_for_changes(self, lines: List[str], filename: str, is_added: bool, 
+                                     changes: List, mode: str = "deep"):
+        """Analyze a code snippet for semantic changes (Java)."""
+        from .change import Change, ChangeKind
+        
+        try:
+            import javalang
+            from javalang.tree import (
+                SynchronizedStatement, MethodInvocation, FieldDeclaration,
+                MethodDeclaration, LocalVariableDeclaration
+            )
+        except ImportError:
+            return
+        
+        code_snippet = "\n".join(lines)
+        
+        try:
+            tokens = list(javalang.tokenizer.tokenize(code_snippet))
+        except:
+            return
+        
+        token_values = [t.value for t in tokens]
+        
+        # Quick token-based checks
+        if "synchronized" in token_values:
+            kind = ChangeKind.MODIFIER_ADDED if is_added else ChangeKind.MODIFIER_REMOVED
+            changes.append(Change(kind=kind, file=filename, symbol="synchronized"))
+            
+        if "volatile" in token_values:
+            kind = ChangeKind.MODIFIER_ADDED if is_added else ChangeKind.MODIFIER_REMOVED
+            changes.append(Change(kind=kind, file=filename, symbol="volatile"))
+        
+        # Check for pattern matches
+        for i in range(len(tokens) - 2):
+            if (tokens[i].value == "." and 
+                tokens[i+1].value == "lock" and 
+                tokens[i+2].value == "("):
+                kind = ChangeKind.CALL_ADDED if is_added else ChangeKind.CALL_REMOVED
+                changes.append(Change(kind=kind, file=filename, symbol="lock"))
+            
+            if (tokens[i].value == "Thread" and 
+                tokens[i+1].value == "." and 
+                tokens[i+2].value == "sleep"):
+                kind = ChangeKind.CALL_ADDED if is_added else ChangeKind.CALL_REMOVED
+                changes.append(Change(kind=kind, file=filename, symbol="sleep"))
+        
+        # Skip deep analysis in light mode
+        if mode == "light":
+            return
+        
+        # Deep AST analysis
+        wrapper_class = f"class Dummy {{ {code_snippet} }}"
+        try:
+            tree = javalang_parse.parse(wrapper_class)
+            self._analyze_tree_changes(tree, filename, is_added, {}, changes)
+        except:
+            pass
+    
+    def _analyze_tree_changes(self, tree, filename: str, is_added: bool, var_map: Dict, changes: List):
+        """Analyze AST tree for changes (Java)."""
+        from .change import Change, ChangeKind
+        
+        try:
+            from javalang.tree import (
+                SynchronizedStatement, MethodInvocation, FieldDeclaration,
+                MethodDeclaration, LocalVariableDeclaration, ForStatement, WhileStatement, DoStatement
+            )
+        except ImportError:
+            return
+        
+        for path, node in tree:
+            if isinstance(node, SynchronizedStatement):
+                kind = ChangeKind.MODIFIER_ADDED if is_added else ChangeKind.MODIFIER_REMOVED
+                changes.append(Change(kind=kind, file=filename, symbol="synchronized"))
+            
+            if isinstance(node, MethodDeclaration):
+                if 'synchronized' in node.modifiers:
+                    kind = ChangeKind.MODIFIER_ADDED if is_added else ChangeKind.MODIFIER_REMOVED
+                    changes.append(Change(kind=kind, file=filename, symbol="synchronized"))
+            
+            if isinstance(node, FieldDeclaration):
+                if 'volatile' in node.modifiers:
+                    kind = ChangeKind.MODIFIER_ADDED if is_added else ChangeKind.MODIFIER_REMOVED
+                    changes.append(Change(kind=kind, file=filename, symbol="volatile"))
+                
+                if node.type:
+                    for declarator in node.declarators:
+                        var_map[declarator.name] = node.type.name
+    
+    def _convert_change_to_signal(self, change) -> Optional[Signal]:
+        """Convert internal Change to Signal (Java)."""
+        from .change import ChangeKind
+        
+        if not hasattr(change, 'kind'):
+            return None
+        
+        # Map Change -> Signal ID
+        sig_id = None
+        if hasattr(change, 'symbol'):
+            if change.symbol == "lock" or change.symbol == "unlock":
+                sig_id = "runtime.concurrency.lock"
+            elif change.symbol == "synchronized":
+                sig_id = "runtime.concurrency.synchronized"
+            elif change.symbol == "volatile":
+                sig_id = "runtime.concurrency.volatile"
+            elif change.symbol == "sleep":
+                sig_id = "runtime.performance.sleep_added"
+        
+        if not sig_id and change.kind == ChangeKind.TYPE_CHANGED:
+            if change.meta.get('downgrade'):
+                sig_id = "runtime.concurrency.thread_safety_downgrade"
+        
+        if not sig_id:
+            return None
+        
+        # Map ChangeKind -> Action
+        action = "changed"
+        if change.kind in [ChangeKind.CALL_ADDED, ChangeKind.FIELD_ADDED, ChangeKind.MODIFIER_ADDED]:
+            action = "added"
+        elif change.kind in [ChangeKind.CALL_REMOVED, ChangeKind.FIELD_REMOVED, ChangeKind.MODIFIER_REMOVED]:
+            action = "removed"
+        elif change.kind == ChangeKind.TYPE_CHANGED:
+            action = "downgrade"
+        
+        return Signal(
+            id=sig_id,
+            file=change.file,
+            action=action,
+            line=getattr(change, 'line_no', None),
+            meta=getattr(change, 'meta', {})
+        )

core/signal_model.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any
+
+@dataclass
+class Signal:
+    id: str
+    file: str
+    confidence: float = 1.0
+    meta: Dict[str, Any] = field(default_factory=dict)
+    action: str = "added"  # "added" or "removed"
+    line: Optional[int] = None
+    
+    def to_dict(self):
+        return {
+            "signal_id": self.id,
+            "file": self.file,
+            "confidence": self.confidence,
+            "meta": self.meta,
+            "action": self.action,
+            "line": self.line
+        }

core/signals_registry.py

@@ -0,0 +1,62 @@
+"""
+DiffSense Signal Registry — single source of truth for all signals emitted by semantic analyzers.
+Rules only consume these signals; they do not emit them.
+Used by: docs/signals.md, CLI `diffsense signals`.
+"""
+from typing import Dict, List
+
+# Grouped by category for docs and CLI output. Order and grouping match docs/signals.md.
+SIGNALS_BY_GROUP: Dict[str, List[str]] = {
+    "runtime.concurrency": [
+        "runtime.concurrency.synchronized",
+        "runtime.concurrency.lock",
+        "runtime.concurrency.lock_removed",
+        "runtime.concurrency.volatile",
+        "runtime.concurrency.volatile_removed",
+        "runtime.concurrency.final_removed",
+        "runtime.concurrency.concurrent_map",
+        "runtime.concurrency.thread_safety_downgrade",
+        "runtime.concurrency.static_unsafe_collection",
+        "runtime.concurrency.atomic_to_non_atomic_write",
+        "runtime.concurrency.threadpool_param_change",
+        "runtime.concurrency.threadpool_creation",
+        "runtime.concurrency.threadpool_unbounded_queue",
+        "runtime.concurrency.executors_factory_risk",
+        "runtime.concurrency.future_get_without_timeout",
+        "runtime.concurrency.busy_wait_added",
+    ],
+    "runtime.performance": [
+        "runtime.performance.sleep_added",
+    ],
+    "runtime.resource": [
+        "runtime.resource.try_with_resource_removed",
+        "runtime.resource.cache_eviction_removed",
+    ],
+    "runtime.network": [
+        "runtime.network.timeout_removed",
+    ],
+    "runtime.data": [
+        "runtime.data.null_check_removed",
+        "runtime.data.equals_to_reference_compare",
+    ],
+    "runtime": [
+        "runtime.input_normalization_removed",
+        "runtime.collection_mutation_inside_loop",
+    ],
+    "data": [
+        "data.pagination_semantic_change",
+    ],
+}
+
+
+def get_all_signals() -> List[str]:
+    """Flat list of all signal IDs, sorted."""
+    out = []
+    for group in SIGNALS_BY_GROUP.values():
+        out.extend(group)
+    return sorted(out)
+
+
+def get_signals_by_group() -> Dict[str, List[str]]:
+    """Signals grouped by category (for CLI and docs)."""
+    return SIGNALS_BY_GROUP.copy()

diffsense-2.2.12.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: diffsense
+Version: 2.2.12
+Summary: MR/PR risk audit: semantic diff + rule engine. Run in CI as image or pip.
+License: Apache-2.0
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: PyYAML
+Requires-Dist: PyGithub
+Requires-Dist: python-gitlab
+Requires-Dist: requests
+Requires-Dist: javalang
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == "mcp"
+Dynamic: license-file

diffsense-2.2.12.dist-info/RECORD

@@ -0,0 +1,58 @@
+banner.py,sha256=JHRCec0w4eGt68IBHJ0y5df4OsuzPiXmWf-FwqJJCA4,1907
+cli.py,sha256=Lcc9bfOTeTgHBNvJtIMAO_3hBqS8M9luIDPAfRhv4vI,27358
+main.py,sha256=XZsJh2TUzEEOi5PkgeYTomg_dYP2Yvoj1f630msGCdc,13768
+run_audit.py,sha256=DpeeNj0B8zIQvM6gtjaZoLUKSrkcJKORsP76-61s7Wk,21909
+adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adapters/base.py,sha256=8WG6uLyvpexEqyynNr7X-WuRyDzE5jOxUV9qdIH7irM,673
+adapters/github_adapter.py,sha256=MgM0i9oGtB746CuK0c4BjrtUux0S8jWVCfes0z7-Dpo,6534
+adapters/gitlab_adapter.py,sha256=g5OWwVLocb2UNPRxVZMZytGsgTyYI7V-8P_0hV_ZEZ0,8636
+adapters/local_adapter.py,sha256=IIYcAWfl7WJEzDIBCC9JGJ1fjGkAUiWcqkugGUeqSLY,5074
+config/__init__.py,sha256=3udbRIyrQB2JnFoFWqL0IAyweo36J5SsJOrMEXMAsjI,50
+config/rules.yaml,sha256=lUGEA-S6hD8XFdCTiS_rZxWb9_xlsZKBtO2h3uPkov8,13309
+core/__init__.py,sha256=wM1ShcscRZ9jB9gwnHsYYPMG4Mp_41FXmmFgo1_eP84,7860
+core/ast_detector.py,sha256=fH7aNgU3oESFgy2FWiaMyVXTVUXeA0LIrAv-2TzBCP4,39590
+core/change.py,sha256=MMQ2M0XO3NmjAQ3aTR9Xm5g651AdjqlUo-LGAlY9PT0,1364
+core/composer.py,sha256=1tN2OEIz501JzPsuGb3PDStgjX_I1ZBxXktDs5iHEk4,3395
+core/evaluator.py,sha256=VqSzezO2CTzIWLfhdFEXtOsm-pZtw_kEQHE1nRUG9Aw,528
+core/ignore_manager.py,sha256=KR9Ec475CcnwAjyXciHmWLl3KZA8OSnvspiVmrVFdXM,2643
+core/knowledge.py,sha256=83KNJu0Pq_JFEVv_J-eepgBaGyYwkA53AefOCHnxhb0,1920
+core/parser.py,sha256=FuU2oF3kMWLNm0hKf45wBDG-r5I4531WDO0CwcTFHqk,6570
+core/parser_manager.py,sha256=QAgU84j_mpqkDXXnG95CbjIroeoAGPMRHsJLQqFMB_Q,3954
+core/quality_manager.py,sha256=GCpzJc643CwpmFQXvfQKs-WIf2fD5hBkmlPEwBPXgBM,4650
+core/renderer.py,sha256=ZMRvTyA08o1sp7yQdJ55-q7w85UdMF-ejgWPHQNa6X4,7661
+core/rule_base.py,sha256=JXaRAjYNf2OVHT5g-5jp6pn49Is0qfq9VW2FiM5yq8g,2792
+core/rule_runtime.py,sha256=pvjPvWwryAAuVVkzMTnIb9fmJ_bQlf1tGqiZDrC1ET4,3583
+core/rules.py,sha256=qcYy0BeVxgdMROz4Y-P72UQ0WwuH36qe_vjJe_mwOSU,30502
+core/run_config.py,sha256=GnVcpVKfJRl3dov3rz2VtxQj2WmeEaIwdBBxJB3Lo50,3730
+core/semantic_diff.py,sha256=OjTc7PBasD8dHQLqpVQ85fV2Q6e0iD7FaoyBnA61YKI,13894
+core/signal_model.py,sha256=4K1yP1i8shMUj0c8Old8bWsrJb2_e5AulqPk88wlbpY,555
+core/signals_registry.py,sha256=BzQzGZ7OMNvZpt33YKiIpbZ1E319xwXB5uXgVpM6l1E,2152
+diffsense-2.2.12.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+diffsense_mcp/__init__.py,sha256=Vf1bx7eiubdiOPap5ZGtDPLdgef6gSXHwyf8JAfRfOc,23
+diffsense_mcp/launcher.py,sha256=bYBl04TdN_A1xSizSlMvsyMDEHqKg7WNt-_PeKmN_HA,721
+diffsense_mcp/server.py,sha256=LvyluHKcVy8hkU5rrbdu6sLi7ZJeJObQP7VOreJB4Y4,20080
+governance/lifecycle.py,sha256=tPTbtjlZ3-nAeN7ZBXy-NSMERh90I_foPitVHHS6gmE,1643
+rules/__init__.py,sha256=Zl9rebPBEdEmqgDW4w9c27HH0VqdbECf3ljRtVIF9jI,6653
+rules/api_compatibility.py,sha256=3XjPH31-pLwawia3eKNECi995KB9HDgMB1U6g5PVHSI,10812
+rules/collection_handling.py,sha256=5QCbHaeeQgV3G05oYnPokD8v1w5XS30wayOFT-hcSqE,10815
+rules/concurrency.py,sha256=eYJiZkwB-iFoUa6W_QO-0cdRGHvtqOH2gTY8tir2swQ,6965
+rules/concurrency_adapter.py,sha256=H3ykRPRy-B9zPatR6Iq8V1sKvqXB3rG1F1NqJYginr0,8285
+rules/cross_language_adapter.py,sha256=hJ7ASYaGfi0Xt8VNa31icn-riFG0Xm-5yUokEnQxL9o,16016
+rules/exception_handling.py,sha256=ewRNqq5abkl7RvS4Upsr1DpOZ2AYuVgS-R-k-iVc8Fg,9851
+rules/go_rules.py,sha256=2bSOwNncon9Os2V3CobPxDMlhdeoyZO1HJ9RFF6TWb0,13100
+rules/null_safety.py,sha256=EozoR8ARWfBB_ygzj_fwjnZxf_CPv42B0YntJCg5eLQ,9500
+rules/resource_management.py,sha256=PJ9KVfNvEcJ2AMJ2pWkYoBEGTSA0KuvZeAJqtyfi7sY,7140
+rules/yaml_adapter.py,sha256=tdXc31Fg0ksBnGYfIMgaMHs8H9X-aObEY_QX9ZRKc0k,7022
+sdk/cpp_adapter.py,sha256=28F0x1KQpsrwlK66mNf10s-HOdZFP-cOHs9GG2psIjE,8002
+sdk/go_adapter.py,sha256=mpT8otbYYgJMQj-Uxfr_Vhl44GOW6Ylndrl3RoHtjG0,6752
+sdk/java_adapter.py,sha256=ykomerEDfSXUrE9yyCnoUmfNGWKCBSdLEZaQv3JjF5I,7297
+sdk/javascript_adapter.py,sha256=C3en-rdGdqrFYPlDPgSsR7EI-Jt_cdumrYWi2zV8vFo,7651
+sdk/language_adapter.py,sha256=iXZl-V8bkEXN0_uDPYafYHMjZRA_ZulNgh3-mcW9bV8,10210
+sdk/python_adapter.py,sha256=6CpceOA4fjli5Vlmq2IC7i0uNAEB8lk8SrD6aFLzedo,6889
+sdk/rule.py,sha256=OpFDygxWJbzHP3OGUOxiqhwZphHc_hgqHZdM-pL2HiA,1840
+sdk/signal.py,sha256=9Q22WR8rAgAqjfNps0GQT7wA5Sfh-Xzhlv2rgl-o0gQ,549
+diffsense-2.2.12.dist-info/METADATA,sha256=7FU5H830pippzhvgU4zb94a11VxGo8Ylz-JKMIRUWAg,496
+diffsense-2.2.12.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+diffsense-2.2.12.dist-info/entry_points.txt,sha256=1gDOb00JZWCulfon24mvvInZabeB2tb3aBz5j7DR4Xg,80
+diffsense-2.2.12.dist-info/top_level.txt,sha256=QnVsGcF6thk9THgrcaD0SVJak5b1gw-fBe7aMvp47FE,82
+diffsense-2.2.12.dist-info/RECORD,,

diffsense-2.2.12.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

diffsense-2.2.12.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+diffsense = cli:app
+diffsense-mcp = diffsense_mcp.server:main