diffimpactscout 0.1.0__py3-none-any.whl

diffimpactscout/scope.py

@@ -0,0 +1,210 @@
+"""DevScope: which files and which lines the developer changed relative to the resolved change base.
+
+Example: after syncing from upstream, only the developer's own commit files
+appear in the change-set, so upstream-merged files are never re-checked.
+"""
+
+import os
+import re
+import sys
+import zlib
+
+import diffimpactscout.base as base
+import diffimpactscout.gitrun as gitrun
+
+CACHE_DIRNAME = "diffimpactscout"
+NONE_SENTINEL = "none"
+
+_HUNK_RE = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+
+
+def default_cache_dir():
+    base_dir = os.environ.get("XDG_CACHE_HOME")
+    if not base_dir:
+        base_dir = os.path.join(os.path.expanduser("~"), ".cache")
+    return os.path.join(base_dir, CACHE_DIRNAME)
+
+
+def cache_key(gitdir, from_ref, to_ref):
+    data = "%s|%s|%s" % (gitdir or "none", from_ref or "", to_ref or "")
+    return "%x" % (zlib.crc32(data.encode("utf-8")) & 0xFFFFFFFF)
+
+
+def parse_hunks(text):
+    hunks = []
+    for line in text.split("\n"):
+        m = _HUNK_RE.match(line)
+        if m:
+            hunks.append(
+                (
+                    int(m.group(1)),
+                    int(m.group(2) or 1),
+                    int(m.group(3)),
+                    int(m.group(4) or 1),
+                )
+            )
+    return hunks
+
+
+def hunk_new_lines(text):
+    lines = set()
+    for _old_start, _old_count, new_start, new_count in parse_hunks(text):
+        for i in range(new_start, new_start + new_count):
+            lines.add(i)
+    return lines
+
+
+class DevScope(object):
+    def __init__(self, root, cache_dir=None):
+        self.root = root
+        self.cache_dir = cache_dir if cache_dir is not None else default_cache_dir()
+        self._gitdir_cache = None
+
+    def _gitdir(self):
+        if self._gitdir_cache is None:
+            self._gitdir_cache = gitrun.git_out(
+                ["rev-parse", "--absolute-git-dir"], self.root
+            )
+        return self._gitdir_cache
+
+    def _cache_path(self, kind, from_ref, to_ref):
+        return os.path.join(
+            self.cache_dir,
+            "%s.%s" % (kind, cache_key(self._gitdir(), from_ref, to_ref)),
+        )
+
+    def _write(self, path, text):
+        try:
+            if not os.path.isdir(self.cache_dir):
+                os.makedirs(self.cache_dir)
+            tmp = path + ".tmp"
+            with open(tmp, "w") as fh:
+                fh.write(text)
+            os.replace(tmp, path)
+        except OSError:
+            pass
+
+    def _write_list(self, path, files):
+        try:
+            if not os.path.isdir(self.cache_dir):
+                os.makedirs(self.cache_dir)
+            tmp = path + ".tmp"
+            with open(tmp, "w") as fh:
+                if files:
+                    fh.write("\n".join(files) + "\n")
+            os.replace(tmp, path)
+        except OSError:
+            pass
+
+    def _read(self, path):
+        try:
+            with open(path, "r") as fh:
+                return fh.read()
+        except (OSError, ValueError):
+            return None
+
+    def _read_list(self, path):
+        content = self._read(path)
+        if content is None:
+            return None
+        return [line for line in content.split("\n") if line]
+
+    def _warn_no_anchor(self):
+        sys.stderr.write(
+            "diffimpactscout: no default upstream ref; falling back to push range\n"
+        )
+
+    def scope_base(self, from_ref=None, to_ref=None):
+        """Resolve the default anchor ref, cached on the (from, to) range."""
+        if from_ref and to_ref:
+            cached = self._cache_path("anchor", from_ref, to_ref)
+            value = self._read(cached)
+            if value is not None:
+                value = value.strip()
+                if value == NONE_SENTINEL:
+                    self._warn_no_anchor()
+                    return None
+                return value
+            ref = base.resolve_change_base(self.root)
+            if ref is None:
+                self._warn_no_anchor()
+                self._write(cached, NONE_SENTINEL)
+                return None
+            self._write(cached, ref)
+            return ref
+        ref = base.resolve_change_base(self.root)
+        if ref is None:
+            self._warn_no_anchor()
+        return ref
+
+    def dev_files(self, anchor, from_ref=None, to_ref=None):
+        """Dev files for the change, cached on the (from, to) range only.
+
+        The anchor is not part of the cache key, so a different anchor with
+        the same range hits a stale cache.
+        """
+        if from_ref and to_ref:
+            cached = self._cache_path("devset", from_ref, to_ref)
+            files = self._read_list(cached)
+            if files is not None:
+                return files
+            files = self._dev_files_uncached(anchor, from_ref, to_ref)
+            self._write_list(cached, files)
+            return files
+        return self._dev_files_uncached(anchor, from_ref, to_ref)
+
+    def _dev_files_uncached(self, anchor, from_ref, to_ref):
+        if anchor:
+            return gitrun.git_nul(
+                ["diff", "--name-only", "-z", "--diff-filter=ACMRT", anchor, "HEAD"],
+                self.root,
+            )
+        if from_ref and to_ref:
+            return gitrun.git_nul(
+                [
+                    "diff",
+                    "--name-only",
+                    "-z",
+                    "--diff-filter=ACMRT",
+                    "%s...%s" % (from_ref, to_ref),
+                ],
+                self.root,
+            )
+        files = set()
+        for args in (
+            ["diff", "--name-only", "-z", "--diff-filter=ACMRT", "HEAD"],
+            ["diff", "--cached", "--name-only", "-z", "--diff-filter=ACMRT"],
+            ["diff", "--name-only", "-z", "--diff-filter=ACMRT"],
+        ):
+            for f in gitrun.git_nul(args, self.root):
+                files.add(f)
+        return sorted(files)
+
+    def changed_lines(self, anchor, path, from_ref=None, to_ref=None):
+        if not self.is_tracked(path):
+            return None
+        if anchor:
+            text = gitrun.git_out(
+                ["diff", "--unified=0", anchor, "HEAD", "--", path], self.root
+            )
+            return hunk_new_lines(text)
+        if from_ref and to_ref:
+            text = gitrun.git_out(
+                ["diff", "--unified=0", "%s...%s" % (from_ref, to_ref), "--", path],
+                self.root,
+            )
+            return hunk_new_lines(text)
+        lines = set()
+        for args in (
+            ["diff", "--unified=0", "HEAD", "--", path],
+            ["diff", "--cached", "--unified=0", "--", path],
+            ["diff", "--unified=0", "--", path],
+        ):
+            lines |= hunk_new_lines(gitrun.git_out(args, self.root))
+        return lines
+
+    def is_tracked(self, path):
+        return gitrun.git_ok(["ls-files", "--error-unmatch", "--", path], self.root)
+
+    def contains(self, anchor, path, from_ref=None, to_ref=None):
+        return path in self.dev_files(anchor, from_ref, to_ref)

diffimpactscout-0.1.0.dist-info/METADATA

@@ -0,0 +1,314 @@
+Metadata-Version: 2.4
+Name: diffimpactscout
+Version: 0.1.0
+Summary: Incremental pre-push guard and AST blast-radius impact analyzer for git repositories.
+Author: DiffImpactScout contributors
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# DiffImpactScout
+
+An incremental pre-push guard and AST blast-radius impact analyzer for git repositories.
+
+- Runs a battery of hygiene, syntax, and linter checks on just the files you changed, before you push.
+- Estimates the blast radius of a change: which Python symbols you touched and where they are referenced across Python, Django templates, and frontend code.
+- Installs as a git pre-push hook that is non-blocking by default, so it informs without getting in the way.
+
+## Features
+
+- Incremental checks: every check is scoped to the change-set or changed lines, not the whole repository.
+- Auto-fixing hygiene checks (line endings, trailing whitespace, end-of-file newline) that clean files in place.
+- Python AST symbol map: detects changed classes, functions, methods, module fields, and class fields, including deletions and renames.
+- Cross-layer impact linking: Python symbols to Django `{% url %}` template tags and frontend `http.get()/post()`-style calls.
+- Symbol cache (`.impact_analysis_cache.json`) so repeated runs skip unchanged files.
+- Profiles for `plain`, `django`, and `fastapi` projects.
+- Configurable pre-push hook installation that never silently clobbers an existing hook.
+
+## Core idea
+
+DiffImpactScout answers one question for a developer about to push: did I break something?
+
+- **Only your changes are analyzed.** Every guard check and the impact report are computed against the diff between your branch and the resolved change base (upstream master or sprint branch when present, otherwise closest origin branch). Pre-existing violations that arrived from upstream or from sync merges are not re-reported, so a run answers "did I introduce this?" instead of "does this file have a problem?"
+- **Non-blocking by default.** A push is only blocked when strictness is explicitly requested (strict mode or an always-block check). Default runs inform without getting in the way.
+- **Fixes over complaints.** Hygiene problems that can be auto-fixed are fixed in place instead of failing the run.
+- **Blast radius, not just lint.** The impact report shows which code outside your diff could be affected by your change, so the "not my change" threshold is applied to blame, not to risk.
+
+The change-set also handles the full breadth of realistic push shapes: direct pushes, force pushes, new branches, sync merges (merge, rebase, squash), stacked branches, shallow clones, repos without a remote anchor, and fork upstream sync. All are covered by the automated pre-push scenario suite, so a missing upstream anchor never silently means "nothing was checked".
+
+## Install
+
+```sh
+pip install diffimpactscout
+```
+
+The package is pure Python (standard library only at runtime) and requires Python 3.6 or newer and the `git` CLI on `PATH`.
+
+Optional tools are only needed for the checks that use them: `ruff`, `eslint` (via `npx`), and `prettier` (via `npx`). If one is missing, the affected check emits a warning and the guard continues; it never blocks a push because a tool is absent.
+
+## Quick start
+
+```sh
+# 1. Write a .diffimpactscout.json config (optional; defaults are used without one)
+diffimpactscout init
+
+# 2. Run the guard checks on your change-set
+diffimpactscout guard
+
+# 3. Analyze the blast radius of your change
+diffimpactscout impact
+
+# 4. Run the guard automatically on every push
+diffimpactscout install-hooks
+```
+
+`init` accepts `--profile plain|django|fastapi` to seed profile-appropriate settings.
+
+## Commands
+
+The `init` command only needs a directory; every other command must be run inside a git repository.
+
+### `diffimpactscout init`
+
+Writes a `.diffimpactscout.json` into the current directory. If the file already exists it is left unchanged.
+
+| Flag | Description |
+| --- | --- |
+| `--profile {plain,django,fastapi}` | Seed defaults from the named profile (default: `plain`). |
+
+### `diffimpactscout guard`
+
+Runs every check listed in `guard.checks` over the change-set and prints any issues. Exits non-zero only when the run is in blocking mode and a blocking check found issues (see [Pre-push hook](#pre-push-hook) and [Configuration](#configuration)).
+
+| Flag | Description |
+| --- | --- |
+| `--staged` | Check only staged files (`git diff --cached`). |
+| `--all` | Check every file tracked by git. |
+| `files...` | Check only the given paths. |
+
+With no flags, the change-set is the diff between your branch and the closest remote ref (upstream preferred, then origin), falling back to the union of committed, staged, and worktree changes when no remote base can be resolved.
+
+### `diffimpactscout impact`
+
+Analyzes the blast radius of the change-set. In an interactive terminal it prints the report and asks `Proceed with push? (Y/n)`; answering `n` or `no` exits non-zero.
+
+| Flag | Description |
+| --- | --- |
+| `--staged` | Analyze the staged diff (base ref becomes `HEAD`). |
+| `--fast` | Skip template and frontend scanning; limit Python scanning to the changed files plus import-linked files. |
+| `--json` | Emit the report as JSON (`{changed_count, rows, unresolved}`) instead of a markdown table. |
+
+### `diffimpactscout check CHECK_ID [files...]`
+
+Runs a single check by id (see [Checks reference](#checks-reference)). With no file arguments it runs against the change-set.
+
+### `diffimpactscout install-hooks`
+
+Installs a `pre-push` git hook that runs `diffimpactscout guard` on push.
+
+| Flag | Description |
+| --- | --- |
+| `--force` | Overwrite an existing `pre-push` hook that DiffImpactScout did not install. |
+| `--uninstall` | Remove the DiffImpactScout `pre-push` hook. |
+
+### `diffimpactscout --version`
+
+Prints the installed version.
+
+## Configuration
+
+DiffImpactScout is configured by a `.diffimpactscout.json` file in the repository root. Without one, the defaults below are used.
+
+```json
+{
+  "version": 1,
+  "mode": "pre-push",
+  "ignore_paths": [
+    "**/node_modules/**",
+    "**/venv/**",
+    "**/.venv/**",
+    "**/migrations/**",
+    "**/staticfiles/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.git/**"
+  ],
+  "use_gitignore": false,
+  "guard": {
+    "checks": [
+      {"id": "hygiene/mixed-line-ending"},
+      {"id": "hygiene/trailing-whitespace"},
+      {"id": "hygiene/end-of-file-fixer"},
+      {"id": "syntax/json-syntax"},
+      {"id": "syntax/ast-syntax"},
+      {"id": "syntax/merge-conflict"},
+      {"id": "repo/large-files", "args": ["--maxkb=250000"]},
+      {"id": "repo/private-key"}
+    ],
+    "blocking": "warn"
+  },
+  "impact": {
+    "profile": "plain",
+    "urls_globs": [],
+    "template_globs": [],
+    "frontend_globs": [],
+    "cache_file": ".impact_analysis_cache.json",
+    "fast_mode": false,
+    "threads": 4
+  }
+}
+```
+
+| Section | Key | Meaning |
+| --- | --- | --- |
+| top-level | `ignore_paths` | Glob patterns (matching any path suffix) excluded from all checks and from impact scanning. |
+| top-level | `use_gitignore` | When `true`, also excludes paths ignored by `git check-ignore`. |
+| `guard` | `checks` | Ordered list of check entries; each `{"id": ...}` may add `args`, `blocking`, and `always_block` overrides. |
+| `guard` | `blocking` | `"warn"` (default) or `"strict"`. In strict mode every check marked blocking can fail the run. |
+| `impact` | `profile` | `plain`, `django`, or `fastapi`; selects route extraction plus default globs. |
+| `impact` | `urls_globs` / `template_globs` / `frontend_globs` | Glob patterns for route files, Django templates, and frontend sources. |
+| `impact` | `cache_file` | Path of the symbol cache (relative to the repo root). |
+| `impact` | `fast_mode`, `threads` | Reserved defaults from `init`; fast mode is currently selected with the `impact --fast` flag. |
+
+A config entry can also declare a custom external check:
+
+```json
+{"id": "my-lint", "type": "external", "command": ["make", "lint"]}
+```
+
+External checks run `command` (each `{file}` placeholder is replaced with the file path) and report a failed exit status as an issue. `scoped` can be `"files"` (command runs once per file) or `"repo"` (once for the whole repository).
+
+### Profiles
+
+- `plain`: no route or cross-layer globs; impact analysis reports only Python references.
+- `django`: route files `**/urls.py`, templates `**/templates/**/*.html`, frontend `**/src/**/*.ts` and `**/app/**/*.js`; guard checks append `ruff` and `ruff-format`.
+- `fastapi`: routes extracted from `**/*.py`, same frontend globs; guard checks append `ruff` and `ruff-format`.
+
+### Blocking behavior
+
+- `guard.blocking` is `"warn"` by default: issues are reported but the run exits `0`. Only checks marked `always_block` (by default just `repo/private-key`) fail the run in warn mode.
+- Set `guard.blocking` to `"strict"` (or export `IMPACT_CHECK_STRICT=1`): every check marked `{"blocking": true}` that finds issues fails the run.
+- Override per check, for example:
+
+```json
+{"id": "syntax/ast-syntax", "always_block": true}
+```
+
+## Pre-push hook
+
+`diffimpactscout install-hooks` writes a `pre-push` hook that runs `diffimpactscout guard` on every push.
+
+- The hook directory is resolved from `git rev-parse --git-common-dir` and honors `core.hooksPath`.
+- The hook script is marked with `# diffimpactscout pre-push hook`. On `--uninstall` (or a re-install with `--force`), only a hook carrying this marker is touched.
+- If a `pre-push` hook already exists without the marker, installation refuses with a `use --force to overwrite` message.
+- The hook runs `diffimpactscout guard`; if the tool is not found, it prints a notice and exits `0`, so pushes are never blocked by a missing install.
+- Because the guard is warn-by-default, an installed hook reports issues without blocking the push unless you enable strict mode.
+
+### Environment variables
+
+| Variable | Effect |
+| --- | --- |
+| `DIFFIMPACTSCOUT_SKIP` | When set (any value), `guard` and `impact` skip entirely and exit `0`. |
+| `IMPACT_CHECK_SKIP` | Legacy alias with the same behavior as `DIFFIMPACTSCOUT_SKIP`. |
+| `IMPACT_CHECK_STRICT` | Falsy values are `0`, `false`, `no`, `off`, and empty; anything else puts `guard` in strict mode and makes `impact` non-interactive runs fail on High/Medium hits. |
+| `PRE_COMMIT_FROM_REF` / `PRE_COMMIT_TO_REF` | Override the diff range used to compute the change-set (e.g. set by a pre-commit-style wrapper). |
+
+## Impact analysis
+
+The `impact` command answers: if I push these changes, what else could break?
+
+1. It parses the change-set (`git diff --find-renames`) and extracts the Python entities you added, removed, or renamed: classes, functions, methods, module fields, and class fields.
+2. It builds an AST symbol map of every tracked Python file in the repo (skipping excluded paths), cached in `impact.cache_file`, and finds every reference to the changed symbols. Lookup kind follows the entity: class fields match attribute loads, methods match name and attribute loads, functions/classes also match imports.
+3. Depending on the profile it extracts routes:
+   - `django`: `path()`/`re_path()`/`url()` entries in `urls_globs` that carry a `name=`.
+   - `fastapi`: `get`/`post`/`put`/`delete`/`patch`/`options` decorators on `router`/`app`-style objects in `urls_globs`.
+4. It links layers: Django templates using `{% url 'name' %}` resolve through the route to its handler; frontend calls (`http.get(...)`, `HttpClient.post(...)`, `$http.delete(...)`) resolve the quoted endpoint to a route by path. References that cannot be resolved to a route land in an "unresolved" bucket flagged for manual checking.
+5. Every impacted reference gets a severity:
+
+| Condition | Severity |
+| --- | --- |
+| Symbol was deleted or renamed | High |
+| Symbol is referenced across 2+ layers (python / template / frontend) | High |
+| Reference is inside a file that is itself in the change-set | Low |
+| No reference path or no changed paths to compare | Low |
+| Otherwise | Medium |
+
+Actions follow severity: High rows say `review/verify`, Medium rows `verify`, Low rows `ok`, and deleted symbols `verify dangling references`.
+
+### Example report excerpt
+
+```
+# Impact Analysis Report
+| # | Impacted File Path | Module / Subsystem | Category | Detected Reference / Usage | Severity | Action Required |
+| --- | --- | --- | --- | --- | --- | --- |
+| 1 | app/views/dashboard.py | app/views | python | render_dashboard (import at dashboard.py:12) | Medium | verify |
+| 2 | app/templates/dashboard.html | app/templates | template | {% url 'dashboard' %} at app/templates/dashboard.html:8 | High | review/verify |
+| 3 | frontend/src/api.ts | frontend/src | frontend | http.get("/dashboard/") at api.ts:41 | Medium | verify |
+
+## Unresolved references (manual check required)
+- {'file': 'frontend/src/api.ts', 'path': '/account/settings', 'dynamic': False}
+
+Summary: 3 changed file(s); High: 1, Medium: 2, Low: 0
+```
+
+In a terminal, `impact` then asks `Proceed with push? (Y/n)`. On a non-interactive run (for example after a CI trigger), the report is shown as a warning and the push is not blocked unless `IMPACT_CHECK_STRICT` is set.
+
+## Checks reference
+
+All checks are incremental: file-scoped checks run on files in the change-set, and line-scoped checks flag only changed lines.
+
+| id | What it checks | Blocks by default? |
+| --- | --- | --- |
+| `hygiene/mixed-line-ending` | Converts CRLF/CR to LF (`--fix=lf` only); auto-fixes files in place. | No (fixes) |
+| `hygiene/trailing-whitespace` | Strips trailing spaces/tabs and trailing blank lines; auto-fixes files in place. | No (fixes) |
+| `hygiene/end-of-file-fixer` | Ensures files end with exactly one newline; auto-fixes files in place. | No (fixes) |
+| `syntax/json-syntax` | Validates that `.json` files parse. | No |
+| `syntax/ast-syntax` | Validates that `.py` files parse as Python. | No |
+| `syntax/merge-conflict` | Flags `<<<<<<<` / `=======` / `>>>>>>>` conflict markers on changed lines. | No |
+| `repo/large-files` | Flags files over `--maxkb` (default 250000). | No |
+| `repo/private-key` | Flags files containing private-key material (RSA, EC, OpenSSH, DSA, PGP blocks). | **Always** |
+| `ruff` | Runs `ruff check` on changed lines of `.py` files (needs `ruff`). | No |
+| `ruff-format` | Runs `ruff format --check` on changed lines (needs `ruff`). | No |
+| `eslint` | Runs `npx eslint` on changed files, honoring a baseline (needs `eslint`). | No |
+| `prettier` | Runs `npx prettier --check` on changed files under `src/` or `app/`, honoring a baseline (needs `prettier`). | No |
+
+"Always" means the check has `always_block: true`, so `repo/private-key` fails the guard even in warn mode: a private key should never be pushed. Every other blocking check only fails the run in strict mode (`guard.blocking: "strict"` or `IMPACT_CHECK_STRICT=1`).
+
+## Requirements
+
+- Python 3.6 or newer.
+- Standard library only at runtime; no third-party dependencies.
+- The `git` CLI on `PATH`.
+- Optional: `ruff`, `eslint`, and `prettier` for their respective checks (missing tools degrade to warnings).
+
+## FAQ
+
+**Why is nothing failing?**
+DiffImpactScout is warn-by-default. `guard` reports issues but exists `0` unless a `repo/private-key` hit, or strict mode is active. The same applies to `impact` in non-interactive contexts.
+
+**How do I make it block?**
+Set `IMPACT_CHECK_STRICT=1` (or any truthy value), or set `"blocking": "strict"` in the `guard` section of `.diffimpactscout.json`. You can also force specific checks to always block with `"always_block": true` on a check entry.
+
+**I want to skip the guard, how?**
+Export either `DIFFIMPACTSCOUT_SKIP` or `IMPACT_CHECK_SKIP` (any value); both `guard` and `impact` will exit `0` without doing anything.
+
+**I already have a pre-push hook.**
+`install-hooks` refuses to overwrite a hook it did not install. Review the existing hook and re-run with `--force` to replace it, or call `guard` from your own hook.
+
+**My templates are in nested or unusual locations.**
+Set `impact.template_globs` (and `frontend_globs`) in the config to cover your layout; use the `django` profile for a sensible starting point.
+
+**The hygiene checks modified my files.**
+That is by design: mixed line endings, trailing whitespace, and missing final newlines are fixed in place. Checks that can fix do so rather than failing; run `diffimpactscout check hygiene/end-of-file-fixer <path>` to apply one fixer to specific files.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

diffimpactscout-0.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+diffimpactscout/__init__.py,sha256=ao0cR4JLPPl_brU_aligQBsmcTkFf_KYHpJNc4tZOXM,110
+diffimpactscout/__main__.py,sha256=br2c-2UJuPrikT004vbqyoAOZAW-W8JISsWLpa_oXwU,168
+diffimpactscout/base.py,sha256=MlYBHpBDZKqfBfQYzgSISxwlxwio6LrA6qyxdcDcjJU,3000
+diffimpactscout/cli.py,sha256=2V63FMg7NOUHd671nGS74YU1Q2KnZ7gUALHAP-jVOvY,6531
+diffimpactscout/config.py,sha256=oxVqRV_LCKb4a4qyZj7tD4_qtL7BASDkRMR_1cWYQnc,5829
+diffimpactscout/env.py,sha256=xP2BIfU5LBsObRCFC3-Ml7GWAbpVlt2CDCY8dzkqi1o,691
+diffimpactscout/gitrun.py,sha256=k57mvt-QCVsDhAsXqdhWgfqzvdXSXzz4fqZjbPyXHC4,1483
+diffimpactscout/guard.py,sha256=B977IFYJ4qF1vudWVqZxfEm9f6ceViC6XtOu-G8sf1c,3155
+diffimpactscout/launcher.py,sha256=zM6BzzqK-_EgPTiILRsbmX-nmaISoRWfOsx5sCPBmCk,3437
+diffimpactscout/scope.py,sha256=4SkqUs8qDOmZAMkemadTQBA_LmZVEzybDy8keV4jqRA,6956
+diffimpactscout/checks/__init__.py,sha256=Ywv2BePUBkLQusUJsYMeG016TiKWWL2C5oL1Uxoab5E,518
+diffimpactscout/checks/base.py,sha256=Fgq-cxH-eouWcUP6mZS2S2yZ_bUQGVhYMFgD3hYV3B4,6655
+diffimpactscout/checks/eslint.py,sha256=VZBm-FsuMnvkUeiyT1j6XMogtDjI1mqAopy-bC1l23k,5005
+diffimpactscout/checks/hygiene.py,sha256=fH-2tsiAMeqj471hjbsqZlck9oPChPXfdOtBEQ2ObaI,3044
+diffimpactscout/checks/prettier.py,sha256=eDHLQjS_KJqm6e81MIXSHBUz4M1Qdij3uc_PjREGqqo,2798
+diffimpactscout/checks/repo_checks.py,sha256=vGv5Yi8qbQgJksuB6XQ6Txy-4lTiVDUfjlv-_1GzbUo,2875
+diffimpactscout/checks/ruff.py,sha256=XZwHtOO7nEH-BvELVADA0zbjpkP7VzJ2cDmsplN-b-o,6327
+diffimpactscout/checks/syntax.py,sha256=2VWEdMj9lQeWCAUNrS2TeR3Rkfwtmk-ALmnoVTHHHc0,4010
+diffimpactscout/impact/__init__.py,sha256=RUvKbfuJVE76KZYJTByPkmke6CO_l9PKUVt5ESLXWs8,89
+diffimpactscout/impact/cache.py,sha256=t-wAjUR_PPYhv8plohMQEShreIfzjyJSCccGp3ubx6U,1413
+diffimpactscout/impact/diff_parser.py,sha256=APtpgxpIbaUnEP1v-9MUdO9V7vB5cN0NxwfJUk5pVJw,5230
+diffimpactscout/impact/impact.py,sha256=vlqMTLI5GJk0oIvZdF54qiZJpLt5iAL47dz1n3NnSdE,10800
+diffimpactscout/impact/python_analyzer.py,sha256=cuAiqBS5mcTtCLL9DyTZFb4qwoNiGPA76mudIoaGNIQ,9527
+diffimpactscout/impact/reporter.py,sha256=cl0yAS4Wedu9dT7dMl3rlQfOacVRoJcf9RQL7563c4U,3045
+diffimpactscout/impact/route_linker.py,sha256=plIwIcIXi16QCpge7V8Te6VMyilz5rVGuieMy1Fg1EA,10747
+diffimpactscout/profiles/django.json,sha256=YoX3a6JOCyiM3w8WUat2OHMOqVOY8JrPQbnfU24V0Ec,279
+diffimpactscout/profiles/fastapi.json,sha256=rpOqdv6ng_ow4eCd_GuvJmHMnEV80hkAMk_vFFg3Ulc,253
+diffimpactscout/profiles/plain.json,sha256=mfmuJPlP2vbGrlk8_GSQEwtCGF9_eXfzfLnlk2sm59M,118
+diffimpactscout-0.1.0.dist-info/licenses/LICENSE,sha256=XOOr2DhCQTG-_JwvRPXRAqz7q6hcNnJILmmMePr-myY,1084
+diffimpactscout-0.1.0.dist-info/METADATA,sha256=pufne3x3ThKJjwJFJVzsm_2p1RFkcX9CwhQaqkeZrcE,16705
+diffimpactscout-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+diffimpactscout-0.1.0.dist-info/entry_points.txt,sha256=I2a_ge2N1ixBJaKGyHLRS3Fox8ifhPnj0hV9NTmrY1g,61
+diffimpactscout-0.1.0.dist-info/top_level.txt,sha256=jpUTpkFX7Ivccy7bkkdBPly0YPx9q3s-4kIG-qxuncc,16
+diffimpactscout-0.1.0.dist-info/RECORD,,

diffimpactscout-0.1.0.dist-info/WHEEL

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

diffimpactscout-0.1.0.dist-info/entry_points.txt

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

diffimpactscout-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DiffImpactScout contributors
+
+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.

diffimpactscout-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+diffimpactscout