guard-cli 0.1.0rc1__py3-none-any.whl

guard/thin_slice.py

@@ -0,0 +1,266 @@
+"""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()
+    )
+
+    g = db.get_graph(graph_name)
+    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-0.1.0rc1.dist-info/METADATA

@@ -0,0 +1,210 @@
+Metadata-Version: 2.4
+Name: guard-cli
+Version: 0.1.0rc1
+Summary: Graph-powered safety layer for AI coding agents built on FalkorDB
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: falkordb>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: coverage>=7.0.0; extra == "dev"
+
+# Guard: Graph-Powered Safety Layer for AI Coding Agents
+
+> **A high-velocity, graph-native regression prevention engine built on FalkorDB.**  
+> Guard selects the exact minimal subset of tests to run after an AI coding agent modifies code, measures a multi-factor **Trust Score**, and deterministically triggers hard fallbacks to full test suites when graph confidence drops.
+
+---
+
+## 1. Problem Statement & Motivation
+
+When AI coding agents (Claude Code, Cursor, Codex, OpenCode) modify complex codebases, running the entire test suite on every step slows iteration cycles to a crawl. Conversely, naive heuristics used by developers or agents to speed things up introduce catastrophic silent escapes:
+
+- **Same-File Heuristic (`same-file`)**: Only runs tests in the matching test file (e.g., changes in `src/flask/helpers.py` $\to$ run `tests/test_helpers.py`). In real production architectures, foundational helpers, middleware, and lifecycle hooks are heavily exercised across disparate modules (`test_basic.py`, `test_blueprints.py`, `test_templating.py`). On the held-out benchmark, **`same-file` suffered a 17.6% Escape Rate** (3 missed failures).
+- **Agent Guessing (`naive-guess`)**: LLMs predicting test paths based on file names or semantic similarity produce identical blind spots and hallucinate coverage.
+- **Run-All Suite (`run-all`)**: 100% safe, but destroys developer velocity and agent autonomy on non-trivial suites.
+
+**Guard's Core Thesis**: Code relationships and test executions form a graph topology. By indexing static AST relationships and per-test dynamic coverage contexts inside **FalkorDB**, Guard computes exact dependency subgraphs, measures empirical test confidence, dynamically widens around ambiguous dynamic dispatch, and enforces hard overrides when evidence is absent.
+
+---
+
+## 2. Verified Benchmark Results (Held-Out Evaluation)
+
+Guard was evaluated against **`pallets/flask`** (494 tests) across 24 held-out mutants under a frozen protocol (`evals/split.json`, `PLAN.md`). 
+
+All metrics are evaluated and reported as **Paired Metrics** (Escape Rate $\leftrightarrow$ Fallback Rate $\leftrightarrow$ Savings Ratio):
+
+| Strategy / Engine | Escape Rate (Paired) | Savings Ratio (Paired) | Fallback Rate (Paired) | Killable Evaluated | Escapes |
+| :--- | :---: | :---: | :---: | :---: | :---: |
+| **`run-all`** (Ground Truth) | 0.0% (0/17) | 0.0% | 100.0% (24/24) | 17 | None |
+| **`same-file`** (Heuristic) | 17.6% (3/17) | 77.3% | 0.0% (0/24) | 17 | `m08`, `m16`, `m30` |
+| **`naive-guess`** (Agent Guess) | 17.6% (3/17) | 77.5% | 0.0% (0/24) | 17 | `m08`, `m16`, `m30` |
+| **`guard` (Full System)** | **0.0% (0/17)** | **67.3%** | **25.0% (6/24)** | 17 | **0 (Zero)** |
+| *Ablation 1: `guard-no-confidence`* | 0.0% (0/17) | 77.1% | 20.8% (5/24) | 17 | None |
+| *Ablation 2: `guard-no-widening`* | 0.0% (0/17) | 73.3% | 25.0% (6/24) | 17 | None |
+
+> **Key Result**: Guard achieved a **0.0% Escape Rate** while delivering **67.3% Test-Time Savings** compared to `run-all`, completely eliminating the 17.6% escape rate of `same-file`.
+
+### Case Study: Root Cause of `m08` Escape Under `same-file`
+- **Mutant `m08`** inverted an `if not` statement in `src/flask/helpers.py:45`.
+- `same-file` and `naive-guess` selected `tests/test_helpers.py` (30 tests) $\to$ **0 failures reported (Escape)**.
+- `guard` traversed FalkorDB `COVERED_BY` edges and detected dependent execution paths in `tests/test_basic.py`, `tests/test_blueprints.py`, and `tests/test_templating.py` (26 tests) $\to$ **Caught failure immediately (0.0% escape)**.
+
+---
+
+## 3. Architecture & System Design
+
+Guard operates as a deterministic, graph-native verification pipeline connecting static code structure, dynamic coverage telemetry, and autonomous agent loops:
+
+1. **AST Diff Analyzer (`guard.thin_slice`)**: Inspects unified git diffs, identifies modified lines, and resolves them to exact function boundaries while flagging test file modifications.
+2. **FalkorDB Graph Engine (`guard.db`)**: Maintains structural call/import relationships and empirical per-test coverage contexts (`COVERED_BY`) in FalkorDB for sub-millisecond Cypher graph traversals.
+3. **Decision Engine (`guard.decision`)**: Pre-emptively checks hard safety overrides (uncovered functions, dynamic dispatch, touched tests), computes the multi-factor Trust Score, and routes execution to the appropriate policy level.
+4. **Self-Healing Feedback Loop (`guard.feedback`)**: Injects high-confidence `miss_repair` edges whenever a missed failure is detected, continuously hardening the graph against future escapes.
+
+
+### 3.1. FalkorDB Graph Schema
+
+The graph layer leverages FalkorDB for low-latency Cypher queries and multi-hop graph traversals:
+
+#### Nodes
+- `(:File {path})`: Source files and test files in the repository.
+- `(:Function {id, file, name, qualname, start, end, has_dynamic_dispatch, no_evidence})`: Function and method definitions.
+- `(:Test {id, file, name, qualname, start, end, flake_rate})`: Pytest test units.
+- `(:Run {id, timestamp, commit_sha, duration_ms, total_tests, passed, failed})`: Historical test execution runs.
+
+#### Edges
+- `(:Function)-[:DEFINED_IN]->(:File)`: Static structural hierarchy.
+- `(:Test)-[:DEFINED_IN]->(:File)`: Static test placement.
+- `(:Function)-[:CALLS {source: 'static', confidence: 0.6, last_verified_sha}]->(:Function)`: Multi-hop static call graph.
+- `(:File)-[:IMPORTS {source: 'static', confidence: 0.6}]->(:File)`: Module import topology.
+- `(:Function)-[:COVERED_BY {source: 'coverage'|'miss_repair', confidence, evidence_count, last_verified_sha}]->(:Test)`: Verified dynamic execution evidence connecting modified functions directly to covering tests.
+- `(:Test)-[:FAILED_IN {source: 'test_run', error_message}]->(:Run)`: Historical test failure records.
+
+---
+
+## 4. Decision Engine & Trust Model
+
+Guard evaluates code changes using a strict two-stage process: **Hard Safety Overrides** followed by the **Empirical Trust Score Policy**.
+
+### 4.1. Hard Safety Overrides (Pre-Emptive Gating)
+Before computing continuous scores, Guard enforces three non-bypassable guardrails:
+1. **Test Files Touched**: If any test file is modified or added, Guard forces `run-all` with a safety warning (modifying assertions could invalidate test isolation).
+2. **Missing Evidence (`no_evidence`)**: If any modified function lacks dynamic coverage evidence in FalkorDB, Guard automatically falls back to `run-all` (never guess when unmapped).
+3. **Dynamic Dispatch Flagged**: If AST analysis flags dynamic dispatch (`getattr`, `setattr`, `eval`, `**kwargs` dispatch), Guard automatically triggers **Dynamic Widening**, expanding the candidate test set to include all module tests.
+
+### 4.2. Trust Score Formula
+When no hard overrides force `run-all`, Guard computes the composite trust metric:
+
+$$\text{Trust} = 0.5 \cdot \text{EvidenceRatio} + 0.3 \cdot \text{Freshness} + 0.2 \cdot (1 - \text{UncertainRatio})$$
+
+- $\text{EvidenceRatio}$: Mean of the highest covering-edge confidence per modified function ($0.0$ for functions without covering edges).
+- $\text{Freshness}$: Proportion of evidence edges whose `last_verified_sha` matches the current commit SHA.
+- $\text{UncertainRatio}$: Proportion of modified functions flagged with dynamic dispatch patterns.
+
+### 4.3. Three-Level Execution Policy
+- **$\text{Trust} \ge 0.8$ (`subset`)**: Execute only the directly covering tests mapped via high-confidence `COVERED_BY` edges.
+- **$0.5 \le \text{Trust} < 0.8$ (`medium`)**: Execute the covering subset plus all tests associated with the modified modules.
+- **$\text{Trust} < 0.5$ (`run-all`)**: Enforce full test suite fallback.
+
+---
+
+## 5. Self-Healing Feedback Loop
+
+When an unexpected regression or missed test failure occurs:
+1. The failure event is captured via `guard feedback --function <func_id> --test <test_id>`.
+2. Guard writes a synthetic repair edge `(:Function)-[:COVERED_BY {source: 'miss_repair', confidence: 1.0}]->(:Test)`.
+3. The `no_evidence` flag on the function is cleared.
+4. Future decisions for this function or its callers automatically select the repaired test, preventing recurring escapes.
+
+---
+
+## 6. Installation & Quickstart
+
+### Prerequisites
+- Python 3.10+
+- Docker & Docker Compose (for FalkorDB)
+
+### 1. Start FalkorDB
+```bash
+docker compose up -d
+# FalkorDB is live on localhost:6379
+# Web UI is accessible on http://localhost:3000
+```
+
+### 2. Install Guard
+```bash
+pip install -e .
+# Or install with dev dependencies:
+pip install -e ".[dev]"
+```
+
+### 3. Ingest Target Repository
+```bash
+# 1. Ingest static AST topology into FalkorDB
+guard ingest-static /path/to/target/repo --include-tests
+
+# 2. Ingest per-test coverage contexts (runs pytest with --cov-context=test)
+guard ingest-coverage /path/to/target/repo --runs 3
+
+# 3. View database statistics
+guard stats
+```
+
+---
+
+## 7. CLI Reference
+
+### `guard run`
+Executes agent pre-completion test verification on the current working tree diff:
+```bash
+guard run --repo /path/to/target/repo
+```
+*Exits with code 0 on success, or code 1 if tests fail or trust is breached, blocking autonomous agents from committing broken code.*
+
+### `guard check`
+Computes the test selection decision without executing tests (outputs JSON or human-readable format):
+```bash
+guard check --repo /path/to/target/repo --json
+```
+
+### `guard callers`
+Traverses multi-hop static call graph in FalkorDB up to $N$ hops:
+```bash
+guard callers "src/flask/app.py::Flask.dispatch_request" --hops 4 --min-confidence 0.6
+```
+
+### `guard covering-tests`
+Queries all tests covering a specific function ordered by edge confidence:
+```bash
+guard covering-tests "src/flask/helpers.py::url_for"
+```
+
+### `guard feedback`
+Repairs the graph after a missed failure:
+```bash
+guard feedback --function "src/flask/helpers.py::url_for" --test "tests/test_helpers.py::test_url_for"
+```
+
+---
+
+## 8. Architectural Trade-offs & Limits
+
+### What Graph-Native Architecture Enables
+- **Deterministic Traceability**: Every skipped test has an explicit, queryable reason (`guard check --json` outputs edge justifications for all known tests).
+- **Cross-Module Awareness**: Identifies deep, non-obvious test linkages across package boundaries that escape keyword search or lexical matching.
+- **Fail-Safe Convergence**: Combines static structure with empirical dynamic execution contexts so that gaps trigger defensive full runs rather than silent failures.
+
+### Known Limits and Edge Cases
+1. **Dynamic Python Metaprogramming**: Heavy dynamic dispatch (`getattr(module, var)()`, custom metaclasses, dynamic decorators) cannot be completely resolved via static AST. *Mitigation*: Guard detects dynamic syntax patterns and triggers dynamic widening or full fallbacks.
+2. **Initial Ingestion Cost**: Generating fine-grained per-test coverage contexts requires an initial baseline run (`pytest --cov-context=test`), which can incur a 1.5x–2.0x slowdown during graph ingestion.
+3. **Ecosystem Scope**: Currently tuned for Python repositories using `pytest`.
+
+---
+
+## 9. Verification & Quality Invariants
+
+Guard development adheres to strict engineering rules (`PLAN.md` R1–R9):
+- **Frozen Benchmarks**: Acceptance claims and split files are immutable and verified through independent verifier runs (`reports/verify_t*.md`).
+- **Zero Flake Tolerance**: Flaky tests are detected during ingest runs and excluded from dynamic evidence edges.
+- **Complete Test Coverage**: Pure decision logic, parsers, and graph writers are covered with unit and integration tests under `tests/`.

guard_cli-0.1.0rc1.dist-info/RECORD

@@ -0,0 +1,15 @@
+guard/__init__.py,sha256=7k8BGYVwznPf9SRb_g3qURokR4KFGdg6kXgk2a9g23g,87
+guard/agent_integration.py,sha256=K7-JHCEhH73FSVkXSyd4wHMLmpu6oJ7ocrttbUWC2rg,4264
+guard/cli.py,sha256=fXp7kWlXO5a5u9bS-8uCS6dzwE88JT06imiHPcqQgQo,6641
+guard/db.py,sha256=fovdVIkoLNNUd-cn0lWXJ12mtuwJuMaTDDnmidhKZzs,8089
+guard/decision.py,sha256=4ce5HKe7hSJkSvXIBraF-deJw6Eb4KL5f2qIMDPeJtU,10475
+guard/feedback.py,sha256=uNE0KfyRRUmjbhKI79zc_ZxI6WdCRjMd03G0cBm-KJE,2786
+guard/thin_slice.py,sha256=f6rhhUsMRjrOvTWLvrdNWjtwyzrARAS88KlIl12Qu0I,9480
+guard/ingest/__init__.py,sha256=pa21RdOiIC9igJzjRXnErQdbMINGd2kP3KuzZllVuSE,35
+guard/ingest/coverage.py,sha256=GixQBSphd_FTUXb-NEXOrxSVLnpp7SA3lqHPWorQsNg,13581
+guard/ingest/static.py,sha256=abE6u_XhaYG1u9B52T_GQBEVBN3vU_tvp4qRNDAvkmc,10290
+guard_cli-0.1.0rc1.dist-info/METADATA,sha256=WrkFHkwy31U488Vu6oBIkMHY6qHpuL2fhYMrwviymLY,11923
+guard_cli-0.1.0rc1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+guard_cli-0.1.0rc1.dist-info/entry_points.txt,sha256=o2V98n4yg8cN6puiafJO8uHqCjnkvRukHTrbn9bfmlM,41
+guard_cli-0.1.0rc1.dist-info/top_level.txt,sha256=wDYWf5msUK3ABsBg4by00UMHAthwEG1wNePS4M571Lo,6
+guard_cli-0.1.0rc1.dist-info/RECORD,,

guard_cli-0.1.0rc1.dist-info/WHEEL

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

guard_cli-0.1.0rc1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+guard = guard.cli:main

guard_cli-0.1.0rc1.dist-info/top_level.txt

@@ -0,0 +1 @@
+guard