guard-cli 0.1.0__py3-none-any.whl

guard/state.py

@@ -0,0 +1,104 @@
+"""Session state tracking for Guard Loop Protection.
+
+Maintains block counts per session in `.guard/state.json` to prevent
+infinite agent stop-hook loops (capping consecutive blocks at 3).
+"""
+from __future__ import annotations
+import json
+import time
+from pathlib import Path
+from typing import Any
+from guard.events import get_guard_dir
+
+
+def _state_file(repo_path: str | Path | None = None) -> Path:
+    return get_guard_dir(repo_path) / "session_state.json"
+
+
+def load_state(repo_path: str | Path | None = None) -> dict[str, Any]:
+    """Loads current state dictionary from .guard/session_state.json."""
+    sf = _state_file(repo_path)
+    if not sf.exists():
+        return {"sessions": {}}
+    try:
+        with open(sf, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            if not isinstance(data, dict):
+                return {"sessions": {}}
+            data.setdefault("sessions", {})
+            return data
+    except Exception:
+        return {"sessions": {}}
+
+
+def save_state(state: dict[str, Any], repo_path: str | Path | None = None) -> None:
+    """Saves state dictionary to .guard/session_state.json safely."""
+    try:
+        sf = _state_file(repo_path)
+        tmp_file = sf.with_suffix(".tmp")
+        with open(tmp_file, "w", encoding="utf-8") as f:
+            json.dump(state, f, indent=2)
+        tmp_file.replace(sf)
+    except Exception:
+        pass
+
+
+def get_session_blocks(session_id: str, repo_path: str | Path | None = None) -> int:
+    """Returns the number of consecutive blocks for a session."""
+    state = load_state(repo_path)
+    session_data = state.get("sessions", {}).get(session_id, {})
+    return int(session_data.get("consecutive_blocks", 0))
+
+
+def record_session_block(session_id: str, repo_path: str | Path | None = None) -> int:
+    """Increments and returns the consecutive block count for a session."""
+    state = load_state(repo_path)
+    sessions = state.setdefault("sessions", {})
+    session_data = sessions.setdefault(session_id, {})
+    
+    current = int(session_data.get("consecutive_blocks", 0)) + 1
+    session_data["consecutive_blocks"] = current
+    session_data["last_blocked_at"] = time.time()
+    
+    save_state(state, repo_path)
+    return current
+
+
+def reset_session_blocks(session_id: str, repo_path: str | Path | None = None) -> None:
+    """Resets consecutive blocks for a session back to 0."""
+    state = load_state(repo_path)
+    sessions = state.setdefault("sessions", {})
+    if session_id in sessions:
+        sessions[session_id]["consecutive_blocks"] = 0
+        sessions[session_id]["last_passed_at"] = time.time()
+        save_state(state, repo_path)
+
+
+def get_last_passed_fingerprint(session_id: str, repo_path: str | Path | None = None) -> str | None:
+    """Returns the working-tree fingerprint that last passed for this session."""
+    state = load_state(repo_path)
+    session_data = state.get("sessions", {}).get(session_id, {})
+    return session_data.get("last_passed_fingerprint")
+
+
+def set_last_passed_fingerprint(
+    session_id: str,
+    fingerprint: str,
+    repo_path: str | Path | None = None,
+) -> None:
+    """Records working-tree fingerprint that passed tests for this session."""
+    state = load_state(repo_path)
+    sessions = state.setdefault("sessions", {})
+    session_data = sessions.setdefault(session_id, {})
+    session_data["last_passed_fingerprint"] = fingerprint
+    session_data["fingerprint_passed_at"] = time.time()
+    save_state(state, repo_path)
+
+
+def clear_last_passed_fingerprint(session_id: str, repo_path: str | Path | None = None) -> None:
+    """Clears cached passed fingerprint when a failure occurs."""
+    state = load_state(repo_path)
+    sessions = state.setdefault("sessions", {})
+    if session_id in sessions and "last_passed_fingerprint" in sessions[session_id]:
+        sessions[session_id].pop("last_passed_fingerprint", None)
+        save_state(state, repo_path)

guard/thin_slice.py

@@ -0,0 +1,278 @@
+"""Thin slice end-to-end decision engine (Task T5a).
+
+Parses a git diff, maps changed line numbers to FalkorDB Function nodes,
+queries covering tests from COVERED_BY edges, and applies crude decision logic:
+- If ANY changed function has no_evidence=true (or 0 covering tests) -> run all.
+- Otherwise -> select the covering tests.
+"""
+from __future__ import annotations
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from guard import db
+
+
+@dataclass
+class ChangedFunction:
+    id: str
+    file: str
+    name: str
+    start: int
+    end: int
+    no_evidence: bool
+    has_dynamic_dispatch: bool = False
+    covering_tests: list[str] = field(default_factory=list)
+
+
+@dataclass
+class CheckResult:
+    status: str  # "select" | "run-all"
+    is_fallback: bool
+    fallback_reason: str | None
+    changed_functions: list[str]
+    selected_tests: list[str]
+    execution_time_ms: float = 0.0
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "status": self.status,
+            "is_fallback": self.is_fallback,
+            "fallback_reason": self.fallback_reason,
+            "changed_functions": self.changed_functions,
+            "selected_tests": self.selected_tests,
+            "selected_tests_count": len(self.selected_tests),
+            "execution_time_ms": self.execution_time_ms,
+        }
+
+
+def parse_unified_diff(diff_text: str) -> dict[str, set[int]]:
+    """Parses a unified diff into a map of {relative_file_path: set(modified_lines)}."""
+    file_lines: dict[str, set[int]] = {}
+    current_file = None
+    current_line = 0
+
+    hunk_regex = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@")
+
+    for line in diff_text.splitlines():
+        if line.startswith("+++ b/"):
+            raw_path = line[6:].strip()
+            # Normalize path: strip repo prefixes if present
+            current_file = raw_path
+            if current_file not in file_lines:
+                file_lines[current_file] = set()
+            current_line = 0
+            continue
+        elif line.startswith("+++ "):
+            raw_path = line[4:].strip()
+            if raw_path != "/dev/null":
+                current_file = raw_path.lstrip("b/")
+                if current_file not in file_lines:
+                    file_lines[current_file] = set()
+            current_line = 0
+            continue
+
+        if not current_file:
+            continue
+
+        hunk_match = hunk_regex.match(line)
+        if hunk_match:
+            current_line = int(hunk_match.group(1))
+            continue
+
+        if line.startswith("+") and not line.startswith("+++"):
+            file_lines[current_file].add(current_line)
+            current_line += 1
+        elif line.startswith("-") and not line.startswith("---"):
+            # Deletion occurs at current_line
+            file_lines[current_file].add(current_line)
+        elif line.startswith(" "):
+            current_line += 1
+
+    return file_lines
+
+
+def resolve_changed_functions(g, file_lines: dict[str, set[int]]) -> list[ChangedFunction]:
+    """Queries FalkorDB to find Function nodes spanning the modified lines."""
+    changed_funcs: dict[str, ChangedFunction] = {}
+
+    for file_path, lines in file_lines.items():
+        if not lines:
+            continue
+
+        # In FalkorDB, File nodes use paths like 'src/flask/config.py'
+        # Query functions defined in this file
+        q = (
+            "MATCH (f:Function) "
+            "WHERE f.file = $file OR f.file ENDS WITH $file OR $file ENDS WITH f.file "
+            "RETURN f.id, f.file, f.name, f.start, f.end, coalesce(f.no_evidence, false), coalesce(f.has_dynamic_dispatch, false)"
+        )
+        res = g.query(q, {"file": file_path}).result_set
+
+        for fid, ffile, fname, start, end, no_evidence, dyn in res:
+            start_i = int(start)
+            end_i = int(end)
+            # Check if any modified line falls within [start, end]
+            if any(start_i <= lineno <= end_i for lineno in lines):
+                if fid not in changed_funcs:
+                    changed_funcs[fid] = ChangedFunction(
+                        id=fid,
+                        file=ffile,
+                        name=fname,
+                        start=start_i,
+                        end=end_i,
+                        no_evidence=bool(no_evidence),
+                        has_dynamic_dispatch=bool(dyn),
+                    )
+
+    return list(changed_funcs.values())
+
+
+def thin_slice_decision(
+    g,
+    changed_functions: list[ChangedFunction],
+    test_files_touched: bool = False,
+    no_confidence_filter: bool = False,
+    no_dynamic_widening: bool = False,
+) -> CheckResult:
+    """Decision logic:
+    - If test files were touched or no functions matched -> run all.
+    - If ANY changed function has no_evidence=true (and not no_confidence_filter) -> run all.
+    - Otherwise -> collect covering tests via COVERED_BY edges (with confidence filter unless ablated).
+    - If dynamic dispatch is present and widening enabled -> include module tests.
+    """
+    if test_files_touched:
+        return CheckResult(
+            status="run-all",
+            is_fallback=True,
+            fallback_reason="Test files were modified in diff",
+            changed_functions=[f.id for f in changed_functions],
+            selected_tests=["tests"],
+        )
+
+    if not changed_functions:
+        return CheckResult(
+            status="run-all",
+            is_fallback=True,
+            fallback_reason="No parsed functions matched diff line changes",
+            changed_functions=[],
+            selected_tests=["tests"],
+        )
+
+    # Hard override: If any function has no evidence -> fallback to run all (unless confidence filter ablated)
+    if not no_confidence_filter:
+        for fn in changed_functions:
+            if fn.no_evidence:
+                return CheckResult(
+                    status="run-all",
+                    is_fallback=True,
+                    fallback_reason=f"Uncovered function has no_evidence=true: {fn.id}",
+                    changed_functions=[f.id for f in changed_functions],
+                    selected_tests=["tests"],
+                )
+
+    # Collect covering tests from graph
+    all_tests = set()
+    min_conf = 0.0 if no_confidence_filter else 0.8
+    for fn in changed_functions:
+        covering = db.get_covering_tests(g, fn.id, min_confidence=min_conf) if g is not None else []
+        fn_tests = [c["test_id"] for c in covering]
+        if not fn_tests and not no_confidence_filter:
+            # No covering tests found
+            return CheckResult(
+                status="run-all",
+                is_fallback=True,
+                fallback_reason=f"No covering tests found with confidence >= 0.8 for: {fn.id}",
+                changed_functions=[f.id for f in changed_functions],
+                selected_tests=["tests"],
+            )
+        fn.covering_tests = fn_tests
+        all_tests.update(fn_tests)
+
+    # Dynamic dispatch widening
+    if not no_dynamic_widening and g is not None:
+        dynamic_funcs = [fn for fn in changed_functions if fn.has_dynamic_dispatch]
+        if dynamic_funcs:
+            for fn in dynamic_funcs:
+                stem = Path(fn.file).stem
+                mod_q = "MATCH (t:Test) WHERE t.file CONTAINS $mod_stem RETURN t.id"
+                try:
+                    mod_res = g.query(mod_q, {"mod_stem": f"test_{stem}"}).result_set
+                    for r in mod_res:
+                        all_tests.add(r[0])
+                except Exception:
+                    pass
+
+    if not all_tests:
+        return CheckResult(
+            status="run-all",
+            is_fallback=True,
+            fallback_reason="No covering tests found",
+            changed_functions=[f.id for f in changed_functions],
+            selected_tests=["tests"],
+        )
+
+    sorted_tests = sorted(all_tests)
+    return CheckResult(
+        status="select",
+        is_fallback=False,
+        fallback_reason=None,
+        changed_functions=[f.id for f in changed_functions],
+        selected_tests=sorted_tests,
+    )
+
+
+def guard_check(
+    diff_text: str | None = None,
+    diff_file: Path | str | None = None,
+    repo_path: Path | str | None = None,
+    graph_name: str = "guard",
+    no_confidence_filter: bool = False,
+    no_dynamic_widening: bool = False,
+) -> CheckResult:
+    """Evaluates a diff and returns the test selection decision."""
+    import time
+    start_time = time.time()
+
+    if diff_text is None:
+        if diff_file:
+            diff_text = Path(diff_file).read_text(encoding="utf-8")
+        else:
+            # Run git diff HEAD in repo_path
+            cwd = str(repo_path) if repo_path else None
+            proc = subprocess.run(["git", "diff", "HEAD"], cwd=cwd, capture_output=True, text=True)
+            diff_text = proc.stdout
+
+    file_lines = parse_unified_diff(diff_text)
+    
+    # Check if test files were touched
+    test_files_touched = any(
+        "test" in p.lower() or p.startswith("tests/")
+        for p in file_lines.keys()
+    )
+
+    # Resolve unique repo graph name if available
+    if repo_path and (graph_name == "guard" or graph_name is None):
+        try:
+            from guard.backend import get_repo_graph_name
+            repo_graph = get_repo_graph_name(repo_path)
+            cand = db.get_graph(repo_graph, repo_path=repo_path)
+            counts = db.get_schema_counts(cand)
+            if sum(counts.values()) > 0:
+                graph_name = repo_graph
+        except Exception:
+            pass
+
+    g = db.get_graph(graph_name, repo_path=repo_path)
+    changed_funcs = resolve_changed_functions(g, file_lines)
+    result = thin_slice_decision(
+        g,
+        changed_funcs,
+        test_files_touched=test_files_touched,
+        no_confidence_filter=no_confidence_filter,
+        no_dynamic_widening=no_dynamic_widening,
+    )
+    result.execution_time_ms = round((time.time() - start_time) * 1000.0, 2)
+    return result

guard_cli/__init__.py

@@ -0,0 +1,37 @@
+"""guard_cli: Graph-powered safety layer for AI coding agents."""
+import guard
+from guard import __version__
+from guard import (
+    api,
+    backend,
+    cli,
+    db,
+    decision,
+    doctor_cmd,
+    events,
+    feedback,
+    hook,
+    init_cmd,
+    state,
+    thin_slice,
+    ingest,
+    integrations,
+)
+
+__all__ = [
+    "__version__",
+    "api",
+    "backend",
+    "cli",
+    "db",
+    "decision",
+    "doctor_cmd",
+    "events",
+    "feedback",
+    "hook",
+    "init_cmd",
+    "state",
+    "thin_slice",
+    "ingest",
+    "integrations",
+]

guard_cli/api.py

@@ -0,0 +1,2 @@
+"""guard_cli.api forwarding module."""
+from guard.api import *

guard_cli/backend.py

@@ -0,0 +1,2 @@
+"""guard_cli.backend forwarding module."""
+from guard.backend import *

guard_cli/cli.py

@@ -0,0 +1,3 @@
+"""guard_cli.cli forwarding module."""
+from guard.cli import *
+from guard.cli import main

guard_cli/db.py

@@ -0,0 +1,2 @@
+"""guard_cli.db forwarding module."""
+from guard.db import *

guard_cli/decision.py

@@ -0,0 +1,2 @@
+"""guard_cli.decision forwarding module."""
+from guard.decision import *

guard_cli/doctor_cmd.py

@@ -0,0 +1,2 @@
+"""guard_cli.doctor_cmd forwarding module."""
+from guard.doctor_cmd import *

guard_cli/events.py

@@ -0,0 +1,2 @@
+"""guard_cli.events forwarding module."""
+from guard.events import *

guard_cli/feedback.py

@@ -0,0 +1,2 @@
+"""guard_cli.feedback forwarding module."""
+from guard.feedback import *

guard_cli/hook.py

@@ -0,0 +1,2 @@
+"""guard_cli.hook forwarding module."""
+from guard.hook import *

guard_cli/ingest/__init__.py

@@ -0,0 +1 @@
+from guard.ingest import *

guard_cli/ingest/coverage.py

@@ -0,0 +1 @@
+from guard.ingest.coverage import *

guard_cli/ingest/static.py

@@ -0,0 +1 @@
+from guard.ingest.static import *

guard_cli/init_cmd.py

@@ -0,0 +1,2 @@
+"""guard_cli.init_cmd forwarding module."""
+from guard.init_cmd import *

guard_cli/integrations/__init__.py

@@ -0,0 +1 @@
+from guard.integrations import *

guard_cli/integrations/claude.py

@@ -0,0 +1 @@
+from guard.integrations.claude import *

guard_cli/state.py

@@ -0,0 +1,2 @@
+"""guard_cli.state forwarding module."""
+from guard.state import *

guard_cli/thin_slice.py

@@ -0,0 +1,2 @@
+"""guard_cli.thin_slice forwarding module."""
+from guard.thin_slice import *