gtg 0.4.0__py3-none-any.whl

goodtogo/parsers/greptile.py

@@ -0,0 +1,249 @@
+"""Greptile parser for classifying comments from Greptile code reviewer.
+
+This module provides the GreptileParser class that implements the ReviewerParser
+interface for parsing and classifying comments from the Greptile automated
+code review tool.
+
+Greptile comments are identified by:
+- Author: "greptile[bot]"
+- Body patterns: Contains "greptile.com" links or "Greptile" branding
+
+Classification rules (per design spec):
+- "Actionable comments posted: 0" -> NON_ACTIONABLE
+- "Actionable comments posted: N" (N > 0) -> ACTIONABLE, MINOR
+- Review summary only -> NON_ACTIONABLE
+- Severity markers (**logic:**, **bug:**, **security:**) -> ACTIONABLE with priority
+- Other -> AMBIGUOUS, UNKNOWN, requires_investigation=True
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from goodtogo.core.interfaces import ReviewerParser
+from goodtogo.core.models import CommentClassification, Priority, ReviewerType
+
+if TYPE_CHECKING:
+    pass
+
+
+class GreptileParser(ReviewerParser):
+    """Parser for Greptile automated code reviewer comments.
+
+    Implements the ReviewerParser interface to classify comments from
+    Greptile based on patterns defined in the GoodToMerge design specification.
+    """
+
+    # Pattern to detect "Actionable comments posted: N" where N is a number
+    ACTIONABLE_PATTERN = re.compile(r"Actionable comments posted:\s*(\d+)", re.IGNORECASE)
+
+    # Pattern to detect Greptile signature/branding in body
+    GREPTILE_SIGNATURE_PATTERN = re.compile(r"greptile\.com|greptile|Greptile", re.IGNORECASE)
+
+    # Patterns indicating a review summary (non-actionable)
+    REVIEW_SUMMARY_PATTERNS = [
+        re.compile(r"^#+\s*(Summary|Review Summary|PR Summary)", re.MULTILINE),
+        re.compile(r"(reviewed|analyzed)\s+(this\s+)?(PR|pull\s+request)", re.IGNORECASE),
+    ]
+
+    # Severity marker patterns for Greptile inline comments
+    # Format: **category:** description (e.g., **logic:** The function...)
+    # These patterns indicate specific issues found by Greptile
+    SEVERITY_PATTERNS: list[tuple[re.Pattern[str], Priority]] = [
+        # Critical severity markers (security, bug, error)
+        (re.compile(r"\*\*security[:\s]", re.IGNORECASE), Priority.CRITICAL),
+        (re.compile(r"\*\*bug[:\s]", re.IGNORECASE), Priority.MAJOR),
+        (re.compile(r"\*\*error[:\s]", re.IGNORECASE), Priority.MAJOR),
+        # Medium severity markers (logic, performance)
+        (re.compile(r"\*\*logic[:\s]", re.IGNORECASE), Priority.MINOR),
+        (re.compile(r"\*\*performance[:\s]", re.IGNORECASE), Priority.MINOR),
+        # Lower severity markers (style, typo, suggestion)
+        (re.compile(r"\*\*style[:\s]", re.IGNORECASE), Priority.TRIVIAL),
+        (re.compile(r"\*\*typo[:\s]", re.IGNORECASE), Priority.TRIVIAL),
+        (re.compile(r"\*\*nitpick[:\s]", re.IGNORECASE), Priority.TRIVIAL),
+    ]
+
+    # PR-level summary comment patterns (non-actionable)
+    # These are posted at the PR level (path=None) and contain overview information.
+    # The actual actionable items are in inline comments.
+    PR_SUMMARY_PATTERNS = [
+        # Greptile Summary HTML header
+        re.compile(r"<h3>Greptile Summary</h3>", re.IGNORECASE),
+        # "N files reviewed" pattern
+        re.compile(r"\d+\s+files?\s+reviewed", re.IGNORECASE),
+        # Edit Code Review Agent Settings link
+        re.compile(r"Edit Code Review Agent Settings", re.IGNORECASE),
+    ]
+
+    @property
+    def reviewer_type(self) -> ReviewerType:
+        """Return the reviewer type this parser handles.
+
+        Returns:
+            ReviewerType.GREPTILE
+        """
+        return ReviewerType.GREPTILE
+
+    def can_parse(self, author: str, body: str) -> bool:
+        """Check if this parser can handle the comment.
+
+        Greptile comments are identified by:
+        1. Author is "greptile[bot]"
+        2. Body contains Greptile signature/links (fallback detection)
+
+        Args:
+            author: Comment author's username/login.
+            body: Comment body text.
+
+        Returns:
+            True if this appears to be a Greptile comment, False otherwise.
+        """
+        # Primary detection: author is greptile bot
+        if author.lower() == "greptile[bot]":
+            return True
+
+        # Fallback detection: body contains Greptile signature
+        if self.GREPTILE_SIGNATURE_PATTERN.search(body):
+            return True
+
+        return False
+
+    def parse(self, comment: dict) -> tuple[CommentClassification, Priority, bool]:
+        """Parse comment and return classification.
+
+        Classification logic (per design spec):
+        1. PR-level summary comments -> NON_ACTIONABLE
+        2. "Actionable comments posted: 0" -> NON_ACTIONABLE
+        3. "Actionable comments posted: N" (N > 0) -> ACTIONABLE, MINOR
+        4. Review summary only -> NON_ACTIONABLE
+        5. Severity markers (**logic:**, **bug:**) -> ACTIONABLE with priority
+        6. Other -> AMBIGUOUS, UNKNOWN, requires_investigation=True
+
+        Args:
+            comment: Dictionary containing comment data with at least:
+                - 'body': Comment text content
+                - 'user': Dictionary with 'login' key
+                - Optionally 'path' and 'line' for inline comments
+
+        Returns:
+            Tuple of (classification, priority, requires_investigation):
+            - classification: CommentClassification enum value
+            - priority: Priority enum value
+            - requires_investigation: Boolean, True for AMBIGUOUS comments
+        """
+        # Check for PR-level summary comments first (highest precedence)
+        # These are posted at the PR level and contain overview information
+        if self._is_pr_summary_comment(comment):
+            return CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False
+
+        body = comment.get("body", "")
+
+        # Check for "Actionable comments posted: N" pattern
+        match = self.ACTIONABLE_PATTERN.search(body)
+        if match:
+            count = int(match.group(1))
+            if count == 0:
+                # No actionable comments
+                return CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False
+            else:
+                # Has actionable comments - classify as ACTIONABLE with MINOR priority
+                return CommentClassification.ACTIONABLE, Priority.MINOR, False
+
+        # Check if this is a review summary (non-actionable)
+        if self._is_review_summary(body):
+            return CommentClassification.NON_ACTIONABLE, Priority.UNKNOWN, False
+
+        # Check for severity markers (**logic:**, **bug:**, etc.)
+        severity_result = self._check_severity_markers(body)
+        if severity_result is not None:
+            return severity_result
+
+        # Default: AMBIGUOUS - cannot determine classification
+        # Per design spec: AMBIGUOUS comments MUST have requires_investigation=True
+        return CommentClassification.AMBIGUOUS, Priority.UNKNOWN, True
+
+    def _is_review_summary(self, body: str) -> bool:
+        """Check if the body is a review summary.
+
+        Review summaries typically contain overview information about
+        the PR without specific actionable items.
+
+        Args:
+            body: Comment body text.
+
+        Returns:
+            True if the body appears to be a review summary.
+        """
+        for pattern in self.REVIEW_SUMMARY_PATTERNS:
+            if pattern.search(body):
+                return True
+        return False
+
+    def _check_severity_markers(
+        self, body: str
+    ) -> tuple[CommentClassification, Priority, bool] | None:
+        """Check for Greptile severity markers in the comment body.
+
+        Greptile uses **category:** format to indicate the type and
+        severity of issues found. For example:
+        - **logic:** indicates a logic error
+        - **security:** indicates a security issue
+        - **bug:** indicates a bug
+
+        Args:
+            body: Comment body text.
+
+        Returns:
+            Tuple of (classification, priority, requires_investigation) if a
+            severity marker is found, None otherwise.
+        """
+        for pattern, priority in self.SEVERITY_PATTERNS:
+            if pattern.search(body):
+                # Trivial priority markers are non-actionable
+                if priority == Priority.TRIVIAL:
+                    return CommentClassification.NON_ACTIONABLE, priority, False
+                return CommentClassification.ACTIONABLE, priority, False
+        return None
+
+    def _is_pr_summary_comment(self, comment: dict) -> bool:
+        """Check if this is a PR-level summary comment.
+
+        PR-level summary comments are posted at the PR level (not inline)
+        and contain overview information like Greptile Summary headers,
+        "N files reviewed" counts, or settings links. These should be
+        classified as NON_ACTIONABLE because the actual actionable items
+        are in inline comments.
+
+        Key criteria:
+        1. Must be a PR-level comment (path=None or missing)
+        2. Must match one of the PR summary patterns
+
+        Args:
+            comment: Dictionary containing comment data with 'body' key,
+                and optionally 'path' and 'line' keys.
+
+        Returns:
+            True if this is a PR-level summary comment that should be
+            classified as NON_ACTIONABLE.
+        """
+        # Only filter PR-level comments (path=None or missing)
+        # Never filter inline comments (they have path/line set)
+        path = comment.get("path")
+        if path is not None:
+            return False
+
+        body = comment.get("body", "")
+        if not body:
+            return False
+
+        # Check for PR summary patterns
+        for pattern in self.PR_SUMMARY_PATTERNS:
+            if pattern.search(body):
+                return True
+
+        # Also check for review summary content at PR level
+        if self._is_review_summary(body):
+            return True
+
+        return False

gtg-0.4.0.dist-info/METADATA

@@ -0,0 +1,278 @@
+Metadata-Version: 2.4
+Name: gtg
+Version: 0.4.0
+Summary: Deterministic PR readiness detection for AI coding agents
+Author-email: David Sifry <david@sifry.com>
+License: MIT
+Project-URL: Homepage, https://github.com/dsifry/goodtogo
+Project-URL: Repository, https://github.com/dsifry/goodtogo
+Project-URL: Issues, https://github.com/dsifry/goodtogo/issues
+Keywords: pr-readiness,github,ai-agents,code-review,ci-cd,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.25.0
+Provides-Extra: redis
+Requires-Dist: redis>=5.0.0; extra == "redis"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: hypothesis>=6.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# Good To Go
+
+**Deterministic PR readiness detection for AI coding agents**
+
+Good To Go helps AI agents (like Claude Code) know exactly when a PR is ready to merge. No guessing, no polling indefinitely, no missing comments.
+
+## The Problem
+
+AI agents creating PRs face a common challenge: **How do I know when I'm actually done?**
+
+- CI is still running... is it done yet?
+- CodeRabbit left 12 comments... which ones need action?
+- A reviewer requested changes... did I address them all?
+- There are 3 unresolved threads... are they blocking?
+
+Without deterministic answers, agents either wait too long, miss comments, or keep asking "is it ready yet?"
+
+## The Solution
+
+Good To Go provides **deterministic PR state analysis** via a simple CLI:
+
+```bash
+gtg 123 --repo owner/repo
+```
+
+Returns (default - AI-friendly):
+- **Exit code 0**: Any analyzable state (ready, action required, threads, CI)
+- **Exit code 4**: Error fetching data
+
+For shell scripting, use `-q` for semantic exit codes without output, or `--semantic-codes` for output with semantic codes.
+
+## Installation
+
+```bash
+pip install gtg
+```
+
+That's it. No other dependencies required.
+
+## Usage
+
+### Basic Check
+
+```bash
+# Check if PR #123 in myorg/myrepo is ready to merge
+gtg 123 --repo myorg/myrepo
+
+# With JSON output for programmatic use
+gtg 123 --repo myorg/myrepo --format json
+
+# Human-readable text format
+gtg 123 --repo myorg/myrepo --format text
+```
+
+### Authentication
+
+Set your GitHub token:
+
+```bash
+export GITHUB_TOKEN=ghp_your_token_here
+```
+
+Note: The CLI reads `GITHUB_TOKEN` from the environment. There is no `--token` flag for security reasons.
+
+### Exit Codes
+
+**Default (AI-friendly)** - returns 0 for all analyzable states:
+
+| Code | Meaning |
+|------|---------|
+| 0 | Any analyzable state (parse the JSON `status` field for details) |
+| 4 | Error fetching PR data |
+
+**With `-q` or `--semantic-codes`** - returns different codes per status:
+
+| Code | Status | Meaning |
+|------|--------|---------|
+| 0 | READY | All clear - good to go! |
+| 1 | ACTION_REQUIRED | Actionable comments need fixes |
+| 2 | UNRESOLVED | Unresolved review threads |
+| 3 | CI_FAILING | CI/CD checks failing |
+| 4 | ERROR | Error fetching PR data |
+
+Use `-q` (quiet mode) for shell scripts that only need the exit code.
+
+### Quick Examples
+
+Here's what the output looks like for each status (using `--format text`):
+
+**READY** - All clear, ready to merge:
+```
+OK PR #123: READY
+   CI: success (5/5 passed)
+   Threads: 3/3 resolved
+```
+
+**ACTION_REQUIRED** - Actionable comments need attention:
+```
+!! PR #456: ACTION_REQUIRED
+   CI: success (5/5 passed)
+   Threads: 8/8 resolved
+
+Action required:
+   - Fix CRITICAL comment from coderabbit in src/db.py:42
+   - 2 comments require investigation (ambiguous)
+```
+
+**UNRESOLVED_THREADS** - Review threads need resolution:
+```
+?? PR #789: UNRESOLVED_THREADS
+   CI: success (5/5 passed)
+   Threads: 2/4 resolved
+
+Action required:
+   - 2 unresolved review threads need attention
+```
+
+**CI_FAILING** - CI checks not passing:
+```
+XX PR #101: CI_FAILING
+   CI: failure (3/5 passed)
+   Threads: 2/2 resolved
+
+Action required:
+   - CI checks are failing - fix build/test errors
+```
+
+### Text Format Status Icons
+
+| Icon | Status | Meaning |
+|------|--------|---------|
+| `OK` | READY | All clear - good to go! |
+| `!!` | ACTION_REQUIRED | Actionable comments need fixes |
+| `??` | UNRESOLVED_THREADS | Unresolved review threads |
+| `XX` | CI_FAILING | CI/CD checks failing |
+| `##` | ERROR | Error fetching PR data |
+
+### JSON Output
+
+```bash
+gtg 123 --repo myorg/myrepo --format json
+```
+
+Returns structured data including:
+- CI status (passed/failed/pending checks)
+- Thread summary (resolved/unresolved counts)
+- Classified comments (actionable vs non-actionable)
+- Action items list
+
+See [USAGE.md](USAGE.md) for full JSON schema and examples.
+
+### GitHub Actions & Branch Protection
+
+Make `gtg` a required check to block merging until PRs are truly ready:
+
+```bash
+# Enable branch protection with gtg-check as required
+# Use actual job names from your CI workflow, not the workflow name
+gh api repos/OWNER/REPO/branches/main/protection -X PUT --input - <<'EOF'
+{
+  "required_status_checks": {
+    "strict": true,
+    "contexts": ["Lint & Format", "Tests (3.9)", "Type Check", "gtg-check"]
+  },
+  "enforce_admins": true,
+  "required_pull_request_reviews": null,
+  "restrictions": null,
+  "allow_force_pushes": false
+}
+EOF
+```
+
+> **Note**: Use actual **job names** (e.g., `"Lint & Format"`) not workflow names (e.g., `"Tests & Quality"`).
+> `enforce_admins: true` means admins must follow all rules. See [USAGE.md](USAGE.md#configuration-options) for details.
+
+See [USAGE.md](USAGE.md#github-actions-integration) for the full GitHub Actions workflow setup.
+
+## Supported Automated Reviewers
+
+Good To Go recognizes and classifies comments from:
+
+- **CodeRabbit** - Critical/Major/Minor/Trivial severity
+- **Greptile** - Actionable comment detection
+- **Claude Code** - Must/should/error/bug patterns
+- **Cursor/Bugbot** - Severity-based classification
+- **Generic** - Fallback for unknown reviewers
+
+## For AI Agents
+
+If you're an AI agent, use Good To Go in your PR workflow:
+
+```python
+import subprocess
+import json
+
+result = subprocess.run(
+    ["gtg", "123", "--repo", "owner/repo", "--format", "json"],
+    capture_output=True,
+    text=True
+)
+
+if result.returncode == 0:
+    print("Good to go! Ready to merge.")
+elif result.returncode == 1:
+    data = json.loads(result.stdout)
+    print(f"Action required: {data['action_items']}")
+```
+
+Or use the Python API directly:
+
+```python
+from goodtogo import PRAnalyzer, Container
+
+container = Container.create_default(github_token="ghp_...")
+analyzer = PRAnalyzer(container)
+
+result = analyzer.analyze("owner", "repo", 123)
+if result.status == "READY":
+    print("Good to go!")
+else:
+    for item in result.action_items:
+        print(f"- {item}")
+```
+
+## Documentation
+
+- [USAGE.md](USAGE.md) - Detailed CLI usage and examples
+- [CONTRIBUTING.md](CONTRIBUTING.md) - Development setup and contribution guide
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Credits
+
+Created by [David Sifry](https://github.com/dsifry) with Claude Code.
+
+---
+
+**Made with Claude Code**

gtg-0.4.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+goodtogo/__init__.py,sha256=V1s47-NTyFDKRlIvbUzmYlDVMMEkeftWz9WszaDqRpg,1736
+goodtogo/cli.py,sha256=I81m0OxqxvgW8l2TaXflQpmfG42D3lq1t4MxMAntg5c,9698
+goodtogo/container.py,sha256=S2_qtVHfXTTOpYszbW9rpL8Fn67xN_12yuA_pfhzG-8,11677
+goodtogo/adapters/__init__.py,sha256=R9sO07B9G14hyn2fvULFCO7V92Bs_DSWXixe3U_BL5o,696
+goodtogo/adapters/agent_state.py,sha256=s7LBB9y_eQ7mX8YhBdS2BO1XEzmwJQPWaEVo-ec5RHQ,17573
+goodtogo/adapters/cache_memory.py,sha256=jT8BZjqa33QMgA7YklBz-Et8uzi5PJ0ufILhvNMmYWs,6897
+goodtogo/adapters/cache_sqlite.py,sha256=Nngf3puxSevgbvqkOoAUoc6E1vnh7KgbVu_u4Ub2qQk,10759
+goodtogo/adapters/github.py,sha256=GH-U6jorx64QZnvXCf3QMfRNJX0e4bzRkZfi4-uiDFo,18960
+goodtogo/adapters/time_provider.py,sha256=xIDGB6KjQiY4KphghUeleMIji_5_fUMkvxHnyh12VNM,3421
+goodtogo/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goodtogo/core/analyzer.py,sha256=zH-O_3sJAItOa2_FE7QYu_68PAfUSki4iDJQiOFu8bc,37880
+goodtogo/core/errors.py,sha256=snFY7Okcf1KlARpKovqe6gxtyy3D5Oi2qvYltWbXHnw,3207
+goodtogo/core/interfaces.py,sha256=7KP9Db5jGvJf-U9JNOgRP3PVBy4TG-bdjBNrwV89rXQ,13004
+goodtogo/core/models.py,sha256=Z-X4Djb0PJmUlI1dAfoq0-B6gZkLn-GVTh4BNevmXbk,7852
+goodtogo/core/validation.py,sha256=-2me14ByMmO80KCqhoUK7DxwsKSK0FillJplO0W6ixM,5023
+goodtogo/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goodtogo/parsers/claude.py,sha256=JwCuoFVkKVOokkVlSopNqsHH3em1QI3v0vF-dH13Nf0,6990
+goodtogo/parsers/coderabbit.py,sha256=Py-YtADRb8gbTAEE5AGbI43zwp580xYWPfLBXmefndU,13582
+goodtogo/parsers/cursor.py,sha256=RmmG877byv59VE6l-X994vqbrdQpVcawfwFbPA7htaM,4465
+goodtogo/parsers/generic.py,sha256=L7S8CpoU73pM49kM3SdWBuJQGaHggeGGw9TMWsKgU8E,7798
+goodtogo/parsers/greptile.py,sha256=AeqG-xi7IhpK1y1YdPTR8wrfkVeimIFVdXx14bYqxIw,9948
+gtg-0.4.0.dist-info/licenses/LICENSE,sha256=pCAhpqrGTNSYSZu5IkJsU9rqu0Zw_7va0IDhcq7E10M,1068
+gtg-0.4.0.dist-info/METADATA,sha256=S9GwNGwXzQIjHdTO-QA7nwtaymP_STzujF7V7dJyVtA,7791
+gtg-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gtg-0.4.0.dist-info/entry_points.txt,sha256=J3FgRI2mHiMFvjW8YIObeJ_CnIrXIDBbaPuITNgwOWk,42
+gtg-0.4.0.dist-info/top_level.txt,sha256=V8uJ2KgslnD-R52ZMwLBC43FZPWCZoxLaOIdBxvk2Ic,9
+gtg-0.4.0.dist-info/RECORD,,

gtg-0.4.0.dist-info/WHEEL

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

gtg-0.4.0.dist-info/entry_points.txt

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

gtg-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Sifry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gtg-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+goodtogo