deadpush 0.2.0__py3-none-any.whl

deadpush/session.py

@@ -0,0 +1,224 @@
+"""
+Vibe Session Tracking — tags guardian activity and file changes into named sessions.
+
+Vibe coding sessions are periods of continuous AI-assisted development. This module
+lets users explicitly start/stop sessions, and the guardian tags all interventions
+with the active session. At session end, a rollup summary is generated showing
+what changed, what went wrong, and what the safety impact was.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+SESSION_DIR = Path.home() / ".deadpush" / "sessions"
+ACTIVE_SESSION_FILE = Path.home() / ".deadpush" / "active_session.json"
+
+
+@dataclass
+class VibeSession:
+    """Represents a single vibe coding session."""
+    id: str
+    label: str
+    start_time: str
+    end_time: str | None = None
+    files_changed: list[str] = field(default_factory=list)
+    incidents: list[dict[str, Any]] = field(default_factory=list)
+    safety_score_start: int = 100
+    safety_score_end: int | None = None
+    total_debris_found: int = 0
+    total_dead_symbols: int = 0
+
+
+class SessionManager:
+    """Manages vibe coding sessions — start, end, status, history."""
+
+    def __init__(self):
+        SESSION_DIR.mkdir(parents=True, exist_ok=True)
+
+    # ------------------------------------------------------------------
+    # Session lifecycle
+    # ------------------------------------------------------------------
+    def start_session(self, label: str = "") -> VibeSession:
+        """Start a new vibe session. Returns the session object."""
+        now = datetime.now()
+        session_id = now.strftime("%Y%m%d_%H%M%S")
+
+        session = VibeSession(
+            id=session_id,
+            label=label or f"Vibe session {session_id}",
+            start_time=now.isoformat(),
+        )
+
+        ACTIVE_SESSION_FILE.write_text(
+            json.dumps(self._session_to_dict(session), indent=2, default=str),
+            encoding="utf-8",
+        )
+        return session
+
+    def end_session(self, safety_score: int | None = None) -> VibeSession | None:
+        """End the active session. Returns the completed session or None."""
+        active = self.get_active_session()
+        if active is None:
+            return None
+
+        now = datetime.now()
+        active.end_time = now.isoformat()
+        active.safety_score_end = safety_score or active.safety_score_start
+
+        # Save to history
+        history_path = SESSION_DIR / f"{active.id}.json"
+        history_path.write_text(
+            json.dumps(self._session_to_dict(active), indent=2, default=str),
+            encoding="utf-8",
+        )
+
+        # Clear active
+        if ACTIVE_SESSION_FILE.exists():
+            ACTIVE_SESSION_FILE.unlink(missing_ok=True)
+
+        # Clean up old sessions (keep last 50)
+        self._cleanup_old_sessions()
+
+        return active
+
+    def get_active_session(self) -> VibeSession | None:
+        """Get the currently active session, if any."""
+        if not ACTIVE_SESSION_FILE.exists():
+            return None
+        try:
+            data = json.loads(ACTIVE_SESSION_FILE.read_text(encoding="utf-8"))
+            return self._dict_to_session(data)
+        except Exception:
+            return None
+
+    def get_session_history(self, limit: int = 20) -> list[VibeSession]:
+        """Get recent completed sessions."""
+        if not SESSION_DIR.exists():
+            return []
+
+        sessions: list[VibeSession] = []
+        for f in sorted(SESSION_DIR.iterdir(), reverse=True):
+            if f.suffix == ".json":
+                try:
+                    data = json.loads(f.read_text(encoding="utf-8"))
+                    sessions.append(self._dict_to_session(data))
+                except Exception:
+                    pass
+                if len(sessions) >= limit:
+                    break
+
+        return sessions
+
+    # ------------------------------------------------------------------
+    # Session tracking helpers (used by guardian)
+    # ------------------------------------------------------------------
+    def record_file_change(self, filepath: str):
+        """Record a file change in the active session."""
+        active = self.get_active_session()
+        if active is None:
+            return
+        if filepath not in active.files_changed:
+            active.files_changed.append(filepath)
+        self._save_active(active)
+
+    def record_incident(self, incident: dict[str, Any]):
+        """Record a guardian incident in the active session."""
+        active = self.get_active_session()
+        if active is None:
+            return
+        active.incidents.append(incident)
+        self._save_active(active)
+
+    def update_safety_score(self, score: int):
+        """Update the running safety score for the session."""
+        active = self.get_active_session()
+        if active is None:
+            return
+        active.safety_score_end = score
+        self._save_active(active)
+
+    def get_session_summary(self, session: VibeSession) -> str:
+        """Generate a human-readable summary of a session."""
+        duration = ""
+        if session.end_time:
+            start = datetime.fromisoformat(session.start_time)
+            end = datetime.fromisoformat(session.end_time)
+            delta = end - start
+            mins = int(delta.total_seconds() / 60)
+            duration = f"{mins}min"
+        else:
+            start = datetime.fromisoformat(session.start_time)
+            elapsed = int((datetime.now() - start).total_seconds() / 60)
+            duration = f"{elapsed}min (active)"
+
+        score_delta = ""
+        if session.safety_score_end is not None:
+            diff = session.safety_score_end - session.safety_score_start
+            if diff < 0:
+                score_delta = f" ↓ {abs(diff)} pts"
+            else:
+                score_delta = f" ↑ {diff} pts"
+
+        return (
+            f"Session: {session.label}\n"
+            f"  Duration: {duration}\n"
+            f"  Files touched: {len(session.files_changed)}\n"
+            f"  Incidents: {len(session.incidents)}\n"
+            f"  Safety: {session.safety_score_start} → {session.safety_score_end or '?'}{score_delta}\n"
+            f"  Debris found: {session.total_debris_found}\n"
+            f"  Dead symbols: {session.total_dead_symbols}"
+        )
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+    def _session_to_dict(self, session: VibeSession) -> dict[str, Any]:
+        return {
+            "id": session.id,
+            "label": session.label,
+            "start_time": session.start_time,
+            "end_time": session.end_time,
+            "files_changed": session.files_changed,
+            "incidents": session.incidents,
+            "safety_score_start": session.safety_score_start,
+            "safety_score_end": session.safety_score_end,
+            "total_debris_found": session.total_debris_found,
+            "total_dead_symbols": session.total_dead_symbols,
+        }
+
+    def _dict_to_session(self, data: dict[str, Any]) -> VibeSession:
+        return VibeSession(
+            id=data.get("id", ""),
+            label=data.get("label", ""),
+            start_time=data.get("start_time", ""),
+            end_time=data.get("end_time"),
+            files_changed=data.get("files_changed", []),
+            incidents=data.get("incidents", []),
+            safety_score_start=data.get("safety_score_start", 100),
+            safety_score_end=data.get("safety_score_end"),
+            total_debris_found=data.get("total_debris_found", 0),
+            total_dead_symbols=data.get("total_dead_symbols", 0),
+        )
+
+    def _save_active(self, session: VibeSession):
+        ACTIVE_SESSION_FILE.write_text(
+            json.dumps(self._session_to_dict(session), indent=2, default=str),
+            encoding="utf-8",
+        )
+
+    def _cleanup_old_sessions(self, keep: int = 50):
+        if not SESSION_DIR.exists():
+            return
+        all_sessions = sorted(SESSION_DIR.iterdir(), reverse=True)
+        for f in all_sessions[keep:]:
+            try:
+                f.unlink()
+            except Exception:
+                pass

deadpush/tests.py

@@ -0,0 +1,333 @@
+"""
+Test Quality Analyzer — detects weak, trivial, or sabotaged AI-generated tests.
+
+AI coding agents frequently produce tests that pass trivially:
+- No assertions (test runs but verifies nothing)
+- Tautological assertions (assert True, assert 1 == 1)
+- Overly broad exception catching (test never fails)
+- Implementation mirroring (test reimplements the logic it's testing)
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+ASSERT_KEYWORDS = {
+    "assert", "assertEqual", "assertEquals", "assertTrue", "assertFalse",
+    "assertIs", "assertIsNot", "assertIsNone", "assertIsNotNone",
+    "assertIn", "assertNotIn", "assertRaises", "assertAlmostEqual",
+    "assertGreater", "assertLess", "assertRegex", "assertCountEqual",
+    "assertDictEqual", "assertListEqual", "assertSetEqual", "assertTupleEqual",
+    "assertMultiLineEqual", "assertSequenceEqual",
+    "expect", "toHaveBeenCalled", "toHaveBeenCalledWith",
+    "toBe", "toEqual", "toMatch", "toContain", "toBeTruthy",
+    "toBeFalsy", "toBeNull", "toBeUndefined", "toBeDefined",
+    "toThrow", "toThrowError", "toStrictEqual", "toHaveProperty",
+    "should", "should.equal", "should.eql", "should.be",
+    "expectThat", "assertThat", "verify",
+    "assert_not_called", "assert_called_once", "assert_called_with",
+    "assert_has_calls", "assert_any_call", "assert_not_awaited",
+}
+
+TAUTOLOGY_PATTERNS = [
+    re.compile(r'assert\s+True\b'),
+    re.compile(r'assert\s+False\b'),
+    re.compile(r'assert\s+1\s*==\s*1'),
+    re.compile(r'assert\s+0\s*==\s*0'),
+    re.compile(r'assert\s+"[^"]*"\s*==\s*"[^"]*"'),
+    re.compile(r'assertEqual\(True,\s*True\)'),
+    re.compile(r'assertEqual\(False,\s*False\)'),
+    re.compile(r'\.toBe\(true\)'),
+    re.compile(r'\.toBe\(false\)'),
+    re.compile(r'\.toEqual\(\{[^}]*\},\s*\{[^}]*\}\)'),
+    re.compile(r'assert\s+is\s+None\s*\n'),
+]
+
+
+BROAD_CATCH_PATTERNS = [
+    re.compile(r'except\s+Exception\s*:'),
+    re.compile(r'except\s*:'),
+    re.compile(r'catch\s*\(\s*(err|e|error)\s*\)\s*\{'),
+]
+
+
+@dataclass
+class TestIssue:
+    """A quality issue found in a test file."""
+    file: str
+    line: int
+    issue_type: str  # "no_assertions" | "tautology" | "broad_catch" | "empty_test"
+    description: str
+    confidence: float = 0.9
+
+
+class TestAnalyzer:
+    """Analyzes test files for quality issues common in AI-generated code."""
+
+    # ------------------------------------------------------------------
+    # Python-specific: AST-based analysis
+    # ------------------------------------------------------------------
+    def _analyze_python_test(self, path: Path, rel_path: str) -> list[TestIssue]:
+        """Deep analysis of Python test files using AST."""
+        issues: list[TestIssue] = []
+        try:
+            source = path.read_text(encoding="utf-8", errors="ignore")
+            tree = ast.parse(source, filename=str(path))
+        except (SyntaxError, Exception):
+            return issues
+
+        for node in ast.walk(tree):
+            # Find test functions (def test_* or def *_test)
+            if isinstance(node, ast.FunctionDef) and (node.name.startswith("test_") or node.name.endswith("_test")):
+                self._check_python_test_function(node, source, path, rel_path, issues)
+
+            # Find test classes (class Test*)
+            if isinstance(node, ast.ClassDef) and node.name.startswith("Test"):
+                for item in node.body:
+                    if isinstance(item, ast.FunctionDef) and (item.name.startswith("test_") or item.name.endswith("_test")):
+                        self._check_python_test_function(item, source, path, rel_path, issues)
+
+        return issues
+
+    def _check_python_test_function(self, node: ast.FunctionDef, source: str, path: Path, rel_path: str, issues: list[TestIssue]):
+        """Check a single Python test function for quality issues."""
+        func_source = ast.get_source_segment(source, node) or ""
+
+        # Count assertion calls
+        has_assertion = False
+        has_tautology = False
+        for child in ast.walk(node):
+            # Direct assert statements
+            if isinstance(child, ast.Assert):
+                has_assertion = True
+                # Check for tautologies
+                if isinstance(child.test, ast.Constant):
+                    if child.test.value is True or child.test.value is False:
+                        has_tautology = True
+                        issues.append(TestIssue(
+                            file=rel_path,
+                            line=child.lineno or node.lineno,
+                            issue_type="tautology",
+                            description=f"Tautological assertion 'assert {child.test.value}' in test '{node.name}'",
+                            confidence=0.95,
+                        ))
+                elif isinstance(child.test, ast.Compare):
+                    if self._is_self_comparison(child.test):
+                        has_tautology = True
+                        issues.append(TestIssue(
+                            file=rel_path,
+                            line=child.lineno or node.lineno,
+                            issue_type="tautology",
+                            description=f"Self-comparison assertion in test '{node.name}'",
+                            confidence=0.92,
+                        ))
+
+            # assertEqual/assertTrue/etc method calls
+            elif isinstance(child, ast.Call) and isinstance(child.func, ast.Attribute):
+                if child.func.attr in ("assertEqual", "assertEquals") and len(child.args) == 2:
+                    has_assertion = True
+                    if self._is_self_comparison_of_args(child.args[0], child.args[1]):
+                        has_tautology = True
+                        issues.append(TestIssue(
+                            file=rel_path,
+                            line=child.lineno or node.lineno,
+                            issue_type="tautology",
+                            description=f"Self-comparison assertEqual in test '{node.name}'",
+                            confidence=0.92,
+                        ))
+                elif child.func.attr in ("assertTrue", "assertFalse"):
+                    has_assertion = True
+                    if child.args and isinstance(child.args[0], ast.Constant) and isinstance(child.args[0].value, bool):
+                        has_tautology = True
+                        issues.append(TestIssue(
+                            file=rel_path,
+                            line=child.lineno or node.lineno,
+                            issue_type="tautology",
+                            description=f"Tautological assert{child.func.attr} in test '{node.name}'",
+                            confidence=0.95,
+                        ))
+
+        # Check for broad exception catching
+        for child in ast.walk(node):
+            if isinstance(child, ast.ExceptHandler):
+                if child.type is None:
+                    issues.append(TestIssue(
+                        file=rel_path,
+                        line=child.lineno or node.lineno,
+                        issue_type="broad_catch",
+                        description=f"Bare 'except:' in test '{node.name}' — test will never fail",
+                        confidence=0.93,
+                    ))
+
+        # Check if test is completely empty or just pass/docstring
+        body_lines = [b for b in node.body if not isinstance(b, (ast.Expr, ast.Pass, ast.Constant))]
+        if not [b for b in node.body if not isinstance(b, (ast.Expr, ast.Pass))] and not has_assertion:
+            issues.append(TestIssue(
+                file=rel_path,
+                line=node.lineno,
+                issue_type="empty_test",
+                description=f"Test '{node.name}' is empty (only docstring/pass)",
+                confidence=0.98,
+            ))
+
+        # No assertions at all
+        if not has_assertion and not has_tautology:
+            # Only flag if it has real code (not just pass/docstring)
+            has_code = any(
+                isinstance(b, (ast.Assign, ast.Call, ast.With, ast.For, ast.While))
+                for b in node.body
+            )
+            if has_code:
+                issues.append(TestIssue(
+                    file=rel_path,
+                    line=node.lineno,
+                    issue_type="no_assertions",
+                    description=f"Test '{node.name}' has no assertions — verifies nothing",
+                    confidence=0.90,
+                ))
+
+    def _is_self_comparison(self, compare: ast.Compare) -> bool:
+        """Check if comparison is against itself (e.g., x == x)."""
+        if len(compare.ops) == 1 and len(compare.comparators) == 1:
+            left = compare.left
+            right = compare.comparators[0]
+            if isinstance(left, ast.Name) and isinstance(right, ast.Name):
+                return left.id == right.id
+            if isinstance(left, ast.Constant) and isinstance(right, ast.Constant):
+                return left.value == right.value
+        return False
+
+    def _is_self_comparison_of_args(self, arg1, arg2) -> bool:
+        """Check if two AST nodes represent the same expression."""
+        if isinstance(arg1, ast.Name) and isinstance(arg2, ast.Name):
+            return arg1.id == arg2.id
+        if isinstance(arg1, ast.Constant) and isinstance(arg2, ast.Constant):
+            return arg1.value == arg2.value
+        return False
+
+    # ------------------------------------------------------------------
+    # Generic (JS/TS/Go/Rust): regex-based analysis
+    # ------------------------------------------------------------------
+    def _analyze_generic_test(self, path: Path, rel_path: str) -> list[TestIssue]:
+        """Regex-based test quality check for non-Python languages."""
+        issues: list[TestIssue] = []
+        try:
+            source = path.read_text(encoding="utf-8", errors="ignore")
+            lines = source.splitlines()
+        except Exception:
+            return issues
+
+        # Find test functions by common patterns
+        test_func_pattern = re.compile(
+            r'(?:it|test|describe)\s*\(?\s*[\'"]([^\'"]+)[\'"]\s*,?\s*(?:function\s*\(|\(|async\s*\(|=>)'
+        )
+        # Jest/Vitest: test('name', () => { ... })
+        # Go: func Test*(t *testing.T)
+        # Rust: #[test] fn test_*
+
+        # For JS/TS, find test blocks and check for assertions
+        in_test = False
+        test_name = ""
+        test_start = 0
+        open_parens = 0
+        has_assert = False
+        has_tautology = False
+
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+
+            # Detect test function start
+            match = test_func_pattern.search(line)
+            if match and ("=>" in stripped or "function" in stripped):
+                if in_test:
+                    # Previous test had no assertions
+                    if not has_assert:
+                        issues.append(TestIssue(
+                            file=rel_path,
+                            line=test_start + 1,
+                            issue_type="no_assertions",
+                            description=f"Test '{test_name}' has no assertions",
+                            confidence=0.85,
+                        ))
+                test_name = match.group(1)
+                test_start = i
+                in_test = True
+                has_assert = False
+
+                # Count braces for scope tracking
+                open_parens = stripped.count("{") - stripped.count("}")
+                continue
+
+            if in_test:
+                # Track braces for end of test
+                open_parens += stripped.count("{") - stripped.count("}")
+                if open_parens <= 0:
+                    in_test = False
+                    if not has_assert:
+                        issues.append(TestIssue(
+                            file=rel_path,
+                            line=test_start + 1,
+                            issue_type="no_assertions",
+                            description=f"Test '{test_name}' has no assertions",
+                            confidence=0.85,
+                        ))
+                    continue
+
+                # Check for assertions
+                if any(kw in stripped for kw in ASSERT_KEYWORDS):
+                    has_assert = True
+
+                # Check for tautologies
+                for pat in TAUTOLOGY_PATTERNS:
+                    if pat.search(stripped):
+                        has_tautology = True
+                        issues.append(TestIssue(
+                            file=rel_path,
+                            line=i + 1,
+                            issue_type="tautology",
+                            description=f"Tautological assertion in test '{test_name}': {stripped[:60]}",
+                            confidence=0.92,
+                        ))
+
+        return issues
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def analyze_file(self, path: Path, rel_path: str) -> list[TestIssue]:
+        """Analyze a single source file for test quality issues."""
+        # Only analyze test files
+        rel_str = rel_path.lower()
+        is_test_file = (
+            rel_str.startswith("test") or "/test" in rel_str or "\\test" in rel_str
+            or rel_str.startswith("spec") or "/spec" in rel_str
+            or rel_str.endswith("_test.go") or rel_str.endswith("_test.rs")
+            or rel_str.endswith(".test.js") or rel_str.endswith(".test.ts")
+            or rel_str.endswith(".spec.js") or rel_str.endswith(".spec.ts")
+            or rel_str.endswith("_test.py") or rel_str.endswith("_test.rs")
+        )
+        if not is_test_file:
+            return []
+
+        if path.suffix == ".py":
+            return self._analyze_python_test(path, rel_path)
+        else:
+            return self._analyze_generic_test(path, rel_path)
+
+    def analyze_batch(self, files: list[Any]) -> list[TestIssue]:
+        """Analyze all test files in a batch."""
+        all_issues: list[TestIssue] = []
+        for f in files:
+            if not getattr(f, "is_text", True):
+                continue
+            try:
+                issues = self.analyze_file(f.path, str(getattr(f, "rel_path", f.path)))
+                all_issues.extend(issues)
+            except Exception:
+                pass
+        return all_issues