adr-drift 0.1.0__py3-none-any.whl

adr_drift/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

adr_drift/cli.py

@@ -0,0 +1,368 @@
+"""ADR Drift: deterministic architecture tests for any language.
+
+Commands:
+  init      scaffold arch.yaml + a sample ADR from the repo's folder layout
+  check     verify the repo against arch.yaml + ADR Constraints (CI-friendly)
+  baseline  record current violations so check --baseline can grandfather them
+  drift     report NEW violations introduced since a git ref
+  new       create the next-numbered ADR from a template
+  index     regenerate the one-sentence-per-ADR index (docs/adr/README.md)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+
+from . import config as config_mod
+from . import engine as engine_mod
+from . import githelp
+from . import rules as rules_mod
+from . import scanner as scanner_mod
+
+VERSION = "0.1.0"
+
+SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv",
+             "dist", "build", ".tox", "vendor", "docs"}
+
+
+def _infer_layers(root: str) -> list[dict]:
+    base = os.path.join(root, "src") if os.path.isdir(
+        os.path.join(root, "src")) else root
+    names = sorted(d for d in os.listdir(base)
+                   if os.path.isdir(os.path.join(base, d))
+                   and d not in SKIP_DIRS and not d.startswith(".")
+                   and d != "tests")
+    prefix = "src/" if base != root else ""
+    return [{"name": n, "paths": [f"{prefix}{n}/**"]} for n in names]
+
+
+ARCH_TEMPLATE = """# ADR Drift architecture config.
+# Layers are matched top-down; the first matching layer wins.
+# Rules use the constraint DSL (see README):
+#   forbid-import: <from> -> <to>      layer/module <from> may not import <to>
+#   forbid-pattern: <glob> !~ <regex>  files matching <glob> must not contain <regex>
+#   require-pattern: <glob> =~ <regex> files matching <glob> must contain <regex>
+layers:
+{layers}
+rules:
+  # Tighten me: uncomment and adapt.
+  # - "forbid-import: handlers -> db.drivers"
+"""
+
+ADR_TEMPLATE = """# {num}: {title}
+
+## Status
+
+Proposed
+
+## Context
+
+Why this decision is being made.
+
+## Decision
+
+What we decided.
+
+## Constraints
+
+Machine-checkable rules ADR Drift enforces in CI. Examples:
+
+- forbid-import: handlers -> db.drivers
+- forbid-pattern: src/**.py !~ \\beval\\(
+- require-pattern: src/handlers/**.py =~ authenticate\\(
+
+## Consequences
+
+What follows from this decision.
+"""
+
+
+def cmd_init(args) -> int:
+    root = args.root
+    arch_path = os.path.join(root, config_mod.ARCH_FILE)
+    if os.path.exists(arch_path) and not args.force:
+        print(f"{config_mod.ARCH_FILE} already exists (use --force to overwrite).")
+        return 2
+    layers = _infer_layers(root)
+    layer_yaml = "".join(
+        f"  - name: {l['name']}\n    paths: {[p for p in l['paths']]}".replace(
+            "'", '"') + "\n" for l in layers)
+    with open(arch_path, "w") as f:
+        f.write(ARCH_TEMPLATE.format(layers=layer_yaml or "  []\n"))
+    adr_dir = os.path.join(root, args.adr_dir)
+    os.makedirs(adr_dir, exist_ok=True)
+    sample = os.path.join(adr_dir, "0001-record-architecture-decisions.md")
+    if not os.path.exists(sample):
+        with open(sample, "w") as f:
+            f.write(ADR_TEMPLATE.format(num=1,
+                                        title="Record architecture decisions"))
+    cmd_index(args)
+    print(f"wrote {config_mod.ARCH_FILE} "
+          f"({len(layers)} layers: {', '.join(l['name'] for l in layers)})")
+    print(f"sample ADR: {os.path.relpath(sample, root)}")
+    print("Next: tighten the rules in arch.yaml, then run `adr-drift check`.")
+    return 0
+
+
+def _load(root, adr_dir):
+    return config_mod.load_all_rules(root, adr_dir)
+
+
+def _print_violations(violations, fmt: str) -> None:
+    if fmt == "json":
+        print(json.dumps([v.as_dict() for v in violations], indent=2))
+        return
+    if not violations:
+        print("✓ no architecture drift — all ADRs hold")
+        return
+    print(f"✗ {len(violations)} architecture violation(s):\n")
+    by_file: dict[str, list] = {}
+    for v in violations:
+        by_file.setdefault(v.file, []).append(v)
+    for path in sorted(by_file):
+        print(f"  {path}")
+        for v in by_file[path]:
+            where = f":{v.line}" if v.line else ""
+            print(f"    {path}{where}: {v.detail}")
+            print(f"      rule: {v.rule.describe()} ({v.rule.source})")
+
+
+def cmd_check(args) -> int:
+    root = args.root
+    try:
+        layers, all_rules, adrs = _load(root, args.adr_dir)
+    except ValueError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 2
+    if not all_rules:
+        print("no rules found — run `adr-drift init` or add a ## Constraints "
+              "section to an ADR.")
+        return 0 if args.fail_on == "none" else 2
+    violations = engine_mod.check(root, layers, all_rules,
+                                  strict_py_only=args.strict_py_only)
+    if args.baseline:
+        keys = _load_baseline(args.baseline, root)
+        if keys is None:
+            return 2
+        violations = [v for v in violations
+                      if (v.file, v.line, v.rule.describe()) not in keys]
+    _print_violations(violations, args.format)
+    if violations and args.fail_on != "none":
+        return 1
+    return 0
+
+
+def _load_baseline(baseline: str, root: str) -> set | None:
+    """Violation identity triples from a baseline file.
+
+    Returns None (after printing an error) when the file can't be read:
+    failing closed beats silently dropping the grandfather list.
+    """
+    path = baseline if os.path.isabs(baseline) else os.path.join(root, baseline)
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, ValueError) as e:
+        print(f"error: cannot read baseline {path}: {e}", file=sys.stderr)
+        return None
+    keys = set()
+    for item in data:
+        keys.add((item.get("file"), item.get("line"), item.get("rule")))
+    return keys
+
+
+def cmd_baseline(args) -> int:
+    root = args.root
+    try:
+        layers, all_rules, _adrs = _load(root, args.adr_dir)
+    except ValueError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 2
+    violations = engine_mod.check(root, layers, all_rules,
+                                  strict_py_only=args.strict_py_only)
+    out = (args.output if os.path.isabs(args.output)
+           else os.path.join(root, args.output))
+    with open(out, "w", encoding="utf-8") as f:
+        json.dump([v.as_dict() for v in violations], f, indent=2)
+        f.write("\n")
+    rel = os.path.relpath(out, root)
+    print(f"wrote {len(violations)} baselined violation(s) -> {rel}")
+    print(f"run `adr-drift check --baseline {rel}` to grandfather them.")
+    return 0
+
+
+def cmd_drift(args) -> int:
+    root = args.root
+    if not githelp.is_repo(root):
+        print("error: not a git repo", file=sys.stderr)
+        return 2
+    try:
+        layers, all_rules, _adrs = _load(root, args.adr_dir)
+    except ValueError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 2
+    if not all_rules:
+        print("no rules found — nothing to drift from.")
+        return 0
+
+    changed = [p for p in githelp.changed_files(root, args.since)
+               if os.path.splitext(p)[1].lower()
+               in (scanner_mod.PY_EXTS | scanner_mod.GENERIC_EXTS)]
+    if not changed:
+        print(f"no source files changed since {args.since} — no drift")
+        return 0
+
+    def entries_for(get_content) -> list:
+        entries = []
+        for rel in changed:
+            content = get_content(rel)
+            if content is None:
+                continue
+            imports, _eng = scanner_mod.extract_imports(rel, content)
+            layer = engine_mod._file_layer(layers, rel)
+            entries.append((rel, layer, imports, content))
+        return entries
+
+    now_entries = entries_for(
+        lambda rel: open(os.path.join(root, rel), encoding="utf-8",
+                         errors="replace").read()
+        if os.path.isfile(os.path.join(root, rel)) else None)
+    base_entries = entries_for(
+        lambda rel: githelp.file_at_ref(root, args.since, rel))
+
+    now_v = {(v.file, v.line, v.rule.describe())
+             for v in engine_mod.evaluate(now_entries, layers, all_rules)}
+    base_v = {(v.file, v.line, v.rule.describe())
+              for v in engine_mod.evaluate(base_entries, layers, all_rules)}
+    new_keys = now_v - base_v
+    fixed_keys = base_v - now_v
+    new_violations = [v for v in engine_mod.evaluate(
+        now_entries, layers, all_rules)
+        if (v.file, v.line, v.rule.describe()) in new_keys]
+    fixed_violations = [v for v in engine_mod.evaluate(
+        base_entries, layers, all_rules)
+        if (v.file, v.line, v.rule.describe()) in fixed_keys]
+
+    if args.format == "json":
+        # Stable contract: the JSON list is the NEW violations, as before.
+        # Fixed violations are reported in the human output.
+        print(json.dumps([v.as_dict() for v in new_violations], indent=2))
+    else:
+        if not new_violations:
+            print(f"✓ no new drift since {args.since} "
+                  f"({len(changed)} file(s) changed)")
+        else:
+            print(f"✗ {len(new_violations)} NEW violation(s) "
+                  f"since {args.since}:\n")
+            for v in new_violations:
+                commit = githelp.blame_commit_for_line(
+                    root, v.file, v.line or 1)
+                tag = f" [{commit}]" if commit else ""
+                print(f"  {v.file}:{v.line or '—'}{tag}: {v.detail}")
+                print(f"      rule: {v.rule.describe()} ({v.rule.source})")
+        if fixed_violations:
+            print(f"\n✓ {len(fixed_violations)} fixed since "
+                  f"{args.since}:\n")
+            for v in fixed_violations:
+                print(f"  {v.file}:{v.line or '—'}: {v.detail} (fixed)")
+                print(f"      rule: {v.rule.describe()} ({v.rule.source})")
+    if new_violations and args.fail_on != "none":
+        return 1
+    return 0
+
+
+def cmd_new(args) -> int:
+    adr_dir = os.path.join(args.root, args.adr_dir)
+    os.makedirs(adr_dir, exist_ok=True)
+    nums = []
+    for f in os.listdir(adr_dir):
+        m = re.match(r"(\d+)[-_]", f)
+        if m:
+            nums.append(int(m.group(1)))
+    n = max(nums, default=0) + 1
+    slug = re.sub(r"[^a-z0-9]+", "-", args.title.lower()).strip("-")
+    path = os.path.join(adr_dir, f"{n:04d}-{slug}.md")
+    with open(path, "w") as f:
+        f.write(ADR_TEMPLATE.format(num=n, title=args.title))
+    print(f"created {os.path.relpath(path, args.root)}")
+    return 0
+
+
+def cmd_index(args) -> int:
+    adr_dir = os.path.join(args.root, args.adr_dir)
+    adrs = [config_mod.parse_adr(p)
+            for p in config_mod.adr_files(args.root, args.adr_dir)]
+    lines = ["# Architecture Decision Records\n",
+             "| # | Title | Status |",
+             "|---|-------|--------|"]
+    for a in adrs:
+        rel = os.path.relpath(a["path"], adr_dir).replace(os.sep, "/")
+        lines.append(f"| {a['number']} | [{a['title']}]({rel}) "
+                     f"| {a['status'] or '—'} |")
+    lines.append("")
+    with open(os.path.join(adr_dir, "README.md"), "w") as f:
+        f.write("\n".join(lines))
+    print(f"indexed {len(adrs)} ADR(s) -> "
+          f"{os.path.join(args.adr_dir, 'README.md')}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="adr-drift",
+        description="Deterministic architecture tests: keep ADRs mechanically true.")
+    p.add_argument("--version", action="version", version=f"%(prog)s {VERSION}")
+    p.add_argument("--root", default=os.getcwd(),
+                   help="Repo root (default: cwd).")
+    p.add_argument("--adr-dir", default=config_mod.DEFAULT_ADR_DIR,
+                   help="ADR directory (default: docs/adr).")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    i = sub.add_parser("init", help="Scaffold arch.yaml + sample ADR.")
+    i.add_argument("--force", action="store_true")
+
+    c = sub.add_parser("check", help="Verify the repo against all rules.")
+    c.add_argument("--format", choices=["human", "json"], default="human")
+    c.add_argument("--fail-on", choices=["violations", "none"],
+                   default="violations")
+    c.add_argument("--strict-py-only", action="store_true",
+                   help="Skip the regex fallback for non-Python files.")
+    c.add_argument("--baseline", default=None, metavar="FILE",
+                   help="Grandfather violations listed in FILE "
+                        "(written by `adr-drift baseline`).")
+
+    b = sub.add_parser("baseline",
+                       help="Record current violations as a grandfather file.")
+    b.add_argument("--output", default=".adr-baseline.json", metavar="FILE",
+                   help="Where to write the baseline "
+                        "(default: .adr-baseline.json under --root).")
+    b.add_argument("--strict-py-only", action="store_true",
+                   help="Skip the regex fallback for non-Python files.")
+
+    d = sub.add_parser("drift", help="New violations since a git ref.")
+    d.add_argument("--since", default="HEAD~5",
+                   help="Git ref to compare against (default: HEAD~5).")
+    d.add_argument("--format", choices=["human", "json"], default="human")
+    d.add_argument("--fail-on", choices=["violations", "none"],
+                   default="violations")
+
+    n = sub.add_parser("new", help="Create the next-numbered ADR.")
+    n.add_argument("title")
+
+    sub.add_parser("index", help="Regenerate the ADR index README.")
+    return p
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    return {"init": cmd_init, "check": cmd_check, "baseline": cmd_baseline,
+            "drift": cmd_drift, "new": cmd_new,
+            "index": cmd_index}[args.cmd](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

adr_drift/config.py

@@ -0,0 +1,87 @@
+"""Config + ADR loading: arch.yaml and docs/adr/*.md Constraints sections."""
+
+from __future__ import annotations
+
+import os
+import re
+
+from . import miniyaml
+from . import rules as rules_mod
+
+DEFAULT_ADR_DIR = "docs/adr"
+ARCH_FILE = "arch.yaml"
+
+CONSTRAINTS_RE = re.compile(
+    r"^##\s+Constraints\s*$", re.IGNORECASE | re.MULTILINE)
+
+
+def load_arch_yaml(root: str) -> tuple[list[dict], list[rules_mod.Rule]]:
+    """Returns (layers, rules). Missing arch.yaml -> ([], [])."""
+    path = os.path.join(root, ARCH_FILE)
+    if not os.path.isfile(path):
+        return [], []
+    with open(path, encoding="utf-8") as f:
+        data = miniyaml.safe_load(f.read()) or {}
+    layers = data.get("layers", []) or []
+    out: list[rules_mod.Rule] = []
+    for i, raw in enumerate(data.get("rules", []) or []):
+        rule = rules_mod.parse_rule_line(str(raw), source=ARCH_FILE,
+                                         line_no=i + 1)
+        if rule:
+            out.append(rule)
+    return layers, out
+
+
+def adr_files(root: str, adr_dir: str = DEFAULT_ADR_DIR) -> list[str]:
+    d = os.path.join(root, adr_dir)
+    if not os.path.isdir(d):
+        return []
+    return sorted(
+        os.path.join(d, f) for f in os.listdir(d)
+        if f.endswith(".md") and f != "README.md")
+
+
+def parse_adr(path: str) -> dict:
+    """Extract number, title, status, and constraint rules from an ADR."""
+    with open(path, encoding="utf-8") as f:
+        text = f.read()
+    info: dict = {"path": path, "number": "", "title": "",
+                  "status": "", "rules": []}
+    m = re.match(r"(\d+)[-_](.+)\.md$", os.path.basename(path))
+    if m:
+        info["number"] = m.group(1)
+        info["title"] = m.group(2).replace("-", " ").replace("_", " ")
+    m = re.search(r"^#\s+(.+)$", text, re.MULTILINE)
+    if m:
+        info["title"] = m.group(1).strip()
+    m = re.search(r"^##\s+Status\s*$\n(.+?)(?=^##\s|\Z)",
+                  text, re.MULTILINE | re.DOTALL | re.IGNORECASE)
+    if m:
+        info["status"] = m.group(1).strip().splitlines()[0].strip()
+    m = CONSTRAINTS_RE.search(text)
+    if m:
+        section = text[m.end():]
+        section = re.split(r"^##\s", section, maxsplit=1,
+                           flags=re.MULTILINE)[0]
+        for i, line in enumerate(section.splitlines(), 1):
+            line = line.strip()
+            if line.startswith(("-", "*")):
+                line = line[1:].strip()
+            try:
+                rule = rules_mod.parse_rule_line(line, source=path,
+                                                 line_no=i)
+            except ValueError as e:
+                raise ValueError(f"{path}: {e}")
+            if rule:
+                info["rules"].append(rule)
+    return info
+
+
+def load_all_rules(root: str, adr_dir: str = DEFAULT_ADR_DIR
+                   ) -> tuple[list[dict], list[rules_mod.Rule], list[dict]]:
+    layers, arch_rules = load_arch_yaml(root)
+    adrs = [parse_adr(p) for p in adr_files(root, adr_dir)]
+    all_rules = list(arch_rules)
+    for a in adrs:
+        all_rules.extend(a["rules"])
+    return layers, all_rules, adrs

adr_drift/engine.py

@@ -0,0 +1,145 @@
+"""Engine: evaluate rules against a scanned repo -> violations."""
+
+from __future__ import annotations
+
+import dataclasses
+import os
+import re
+
+from . import rules as rules_mod
+from . import scanner as scanner_mod
+
+
+@dataclasses.dataclass
+class Violation:
+    rule: rules_mod.Rule
+    file: str          # repo-relative path
+    line: int          # 0 when the whole file is the subject
+    detail: str
+
+    def as_dict(self) -> dict:
+        return {
+            "rule": self.rule.describe(),
+            "rule_source": (f"{self.rule.source}:{self.rule.line_no}"
+                            if self.rule.line_no else self.rule.source),
+            "file": self.file,
+            "line": self.line,
+            "detail": self.detail,
+        }
+
+
+def _rel(root: str, path: str) -> str:
+    return os.path.relpath(path, root).replace(os.sep, "/")
+
+
+def _file_layer(layers: list[dict], rel_path: str) -> str:
+    for layer in layers:
+        for pat in layer.get("paths", []):
+            if rules_mod.match_glob(pat, rel_path):
+                return layer.get("name", "")
+    return ""
+
+
+def _layer_path_prefixes(layer: dict) -> list[str]:
+    """Dotted module prefixes implied by a layer's path globs.
+
+    Only the literal leading components count (up to the first
+    wildcard): "src/db/**" -> ["src.db"], "handlers/**" -> ["handlers"].
+    """
+    prefixes: list[str] = []
+    for pat in layer.get("paths", []):
+        lit: list[str] = []
+        for part in pat.replace("\\", "/").strip("/").split("/"):
+            if any(ch in part for ch in "*?["):
+                break
+            lit.append(part)
+        if lit:
+            prefixes.append(".".join(lit))
+    return prefixes
+
+
+def _import_identities(mod: str, layers: list[dict]) -> list[str]:
+    """Every name an imported module can be known by.
+
+    Besides the literal module ("src.db.drivers") this includes the
+    layer name(s) whose paths contain it ("db") and the module with the
+    layer's top-level source dir stripped ("db.drivers"). Without this,
+    src/-layout repos where code is imported as "src.db.x" silently
+    dodge every to-side pattern that names the layer.
+    """
+    ids = [mod]
+    for layer in layers:
+        name = layer.get("name", "")
+        for prefix in _layer_path_prefixes(layer):
+            if not rules_mod.match_pat(prefix, mod):
+                continue
+            if name and name not in ids:
+                ids.append(name)
+            parts = prefix.split(".")
+            if len(parts) >= 2 and mod.startswith(parts[0] + "."):
+                stripped = mod[len(parts[0]) + 1:]
+                if stripped and stripped not in ids:
+                    ids.append(stripped)
+    return ids
+
+
+def check(root: str, layers: list[dict], all_rules: list[rules_mod.Rule],
+          strict_py_only: bool = False) -> list[Violation]:
+    entries: list[tuple[str, str, list[tuple[str, int]], str]] = []
+    for path in scanner_mod.iter_source_files(root):
+        rel = _rel(root, path)
+        try:
+            with open(path, encoding="utf-8", errors="replace") as f:
+                content = f.read()
+        except OSError:
+            continue
+        imports, _engine = scanner_mod.extract_imports(
+            rel, content, strict_py_only=strict_py_only)
+        entries.append((rel, _file_layer(layers, rel), imports, content))
+    return evaluate(entries, layers, all_rules)
+
+
+def evaluate(entries: list[tuple[str, str, list[tuple[str, int]], str]],
+             layers: list[dict],
+             all_rules: list[rules_mod.Rule]) -> list[Violation]:
+    """Evaluate rules against pre-scanned entries.
+
+    Each entry: (rel_path, layer, imports[(module, line)], content).
+    Lets `drift` check historical git content through the same engine.
+    """
+    violations: list[Violation] = []
+    for rule in all_rules:
+        if rule.kind == "forbid-import":
+            for rel, layer, imports, _content in entries:
+                # The "from" side matches the file's layer name OR a module
+                # prefix of the file path (so rules work without layers).
+                from_hit = (layer and rules_mod.match_pat(rule.from_pat, layer))
+                mod_prefix = rel.replace("/", ".").rsplit(".", 1)[0]
+                if not from_hit:
+                    from_hit = rules_mod.match_pat(rule.from_pat, mod_prefix)
+                if not from_hit:
+                    continue
+                for mod, lineno in imports:
+                    if any(rules_mod.match_pat(rule.to_pat, ident)
+                           for ident in _import_identities(mod, layers)):
+                        violations.append(Violation(
+                            rule=rule, file=rel, line=lineno,
+                            detail=f"imports {mod}"))
+        else:
+            rx = re.compile(rule.regex)
+            for rel, _layer, _imports, content in entries:
+                if not rules_mod.match_glob(rule.glob, rel):
+                    continue
+                if rule.kind == "forbid-pattern":
+                    for i, line in enumerate(content.splitlines(), 1):
+                        if rx.search(line):
+                            violations.append(Violation(
+                                rule=rule, file=rel, line=i,
+                                detail=f"matches /{rule.regex}/"))
+                else:  # require-pattern
+                    if not rx.search(content):
+                        violations.append(Violation(
+                            rule=rule, file=rel, line=0,
+                            detail=f"missing /{rule.regex}/"))
+    violations.sort(key=lambda v: (v.file, v.line))
+    return violations

adr_drift/githelp.py

@@ -0,0 +1,62 @@
+"""Git helpers for `adr-drift drift`: what did recent commits introduce?"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+
+
+def _git(root: str, *args: str) -> str:
+    p = subprocess.run(["git", "-C", root, *args],
+                       capture_output=True, text=True, timeout=30)
+    if p.returncode != 0:
+        raise RuntimeError(f"git {' '.join(args)} failed: {p.stderr.strip()}")
+    return p.stdout
+
+
+def is_repo(root: str) -> bool:
+    try:
+        _git(root, "rev-parse", "--git-dir")
+        return True
+    except Exception:
+        return False
+
+
+def changed_files(root: str, since: str) -> list[str]:
+    """Repo-relative paths changed between <since> and HEAD."""
+    out = _git(root, "diff", "--name-only", f"{since}..HEAD")
+    return [l.strip() for l in out.splitlines() if l.strip()]
+
+
+def file_at_ref(root: str, ref: str, rel_path: str) -> str | None:
+    """File content at a git ref, or None if the file didn't exist."""
+    p = subprocess.run(["git", "-C", root, "show", f"{ref}:{rel_path}"],
+                       capture_output=True, text=True, timeout=30)
+    if p.returncode != 0:
+        return None
+    return p.stdout
+
+
+def recent_commits(root: str, n: int) -> list[dict]:
+    out = _git(root, "log", f"-{n}", "--format=%H%x01%h%x01%s")
+    commits = []
+    for line in out.splitlines():
+        parts = line.split("\x01")
+        if len(parts) == 3:
+            commits.append({"sha": parts[0], "short": parts[1],
+                            "subject": parts[2]})
+    return commits
+
+
+def blame_commit_for_line(root: str, rel_path: str, lineno: int) -> str:
+    """Short sha of the commit that introduced a given line (best effort)."""
+    try:
+        out = _git(root, "blame", "--porcelain", "-L", f"{lineno},{lineno}",
+                   "HEAD", "--", rel_path)
+        for line in out.splitlines():
+            if len(line) >= 40 and all(
+                    c in "0123456789abcdef" for c in line[:40]):
+                return line[:7]
+    except Exception:
+        pass
+    return ""

adr_drift/miniyaml.py

@@ -0,0 +1,273 @@
+"""Minimal YAML subset parser (stdlib only).
+
+Handles the subset these tools need:
+  - block mappings and lists, nested by indentation
+  - inline-map list items ("- key: value")
+  - flow-style lists of scalars ("[a, b]")
+  - scalars: quoted strings, ints, floats, bools, null
+  - "#" comments (outside quotes)
+
+SHARED COPY: the canonical version lives here in adr_drift/miniyaml.py.
+pr_verify and promptregress carry verbatim copies (see their headers).
+Do not fork — fix the canonical copy and re-copy.
+
+NOT supported (raises ValueError): anchors, aliases, tags, multi-line
+(|, >) scalars, flow maps, duplicate keys. Configs using them get a
+clear error naming the feature and the line number.
+
+Strictness notes:
+  - Every ValueError carries a line number: "miniyaml: <what> (line N)".
+  - Unclosed flow lists ("a: [x"), embedded mapping indicators
+    ("a: b: c"), unterminated quotes, and nested flow collections are
+    rejected instead of silently misparsed.
+  - Nesting deeper than MAX_DEPTH (50) raises ValueError, never
+    RecursionError.
+"""
+
+from __future__ import annotations
+
+import re
+
+_KEY_RE = re.compile(r"^([A-Za-z0-9_.\-/ ]+):(?:\s|$)")
+
+#: Deepest block-nesting level accepted. Deeper input raises ValueError
+#: (the parser's error contract) instead of RecursionError.
+MAX_DEPTH = 50
+
+
+def _err(msg: str, lineno: int) -> ValueError:
+    return ValueError(f"miniyaml: {msg} (line {lineno})")
+
+
+def _strip_comment(line: str) -> str:
+    in_s = in_d = False
+    for i, ch in enumerate(line):
+        if ch == "'" and not in_d:
+            in_s = not in_s
+        elif ch == '"' and not in_s:
+            in_d = not in_d
+        elif ch == "#" and not in_s and not in_d:
+            if i == 0 or line[i - 1] in " \t":
+                return line[:i]
+    return line
+
+
+def _scalar(s: str):
+    s = s.strip()
+    if len(s) >= 2 and s[0] == s[-1] and s[0] in "\"'":
+        inner = s[1:-1]
+        if s[0] == '"':
+            inner = inner.replace('\\"', '"').replace("\\\\", "\\")
+        return inner
+    low = s.lower()
+    if low in ("null", "~", "none", ""):
+        return None
+    if low in ("true", "yes", "on"):
+        return True
+    if low in ("false", "no", "off"):
+        return False
+    try:
+        return int(s)
+    except ValueError:
+        pass
+    try:
+        return float(s)
+    except ValueError:
+        pass
+    return s
+
+
+def _check_no_mapping_indicator(v: str, lineno: int):
+    """Reject ':' inside a plain scalar ("a: b: c") — PyYAML rejects it too.
+
+    v is an unquoted scalar here; stray quote chars are tracked so a
+    colon inside e.g. "it's: fine" does not false-positive.
+    """
+    in_s = in_d = False
+    for i, ch in enumerate(v):
+        if ch == "'" and not in_d:
+            in_s = not in_s
+        elif ch == '"' and not in_s:
+            in_d = not in_d
+        elif ch == ":" and not in_s and not in_d:
+            nxt = v[i + 1] if i + 1 < len(v) else ""
+            if nxt in ("", " ", "\t"):
+                raise _err(
+                    "unexpected ':' in scalar "
+                    f"(nested mappings need their own lines): {v!r}",
+                    lineno,
+                )
+
+
+def _check_value(val: str, lineno: int, in_flow: bool = False):
+    """Reject unsupported/malformed value shapes before _scalar() sees them.
+
+    Anchors (&), aliases (*), and tags (!) are named explicitly so a
+    config using them fails loudly instead of silently dropping content.
+    """
+    v = val.strip()
+    if not v:
+        return
+    c0 = v[0]
+    if c0 == "&":
+        raise _err("YAML anchors (&) are not supported", lineno)
+    if c0 == "*":
+        raise _err("YAML aliases (*) are not supported", lineno)
+    if c0 == "!":
+        raise _err("YAML tags (!) are not supported", lineno)
+    if c0 in ("|", ">"):
+        raise _err("multi-line (|, >) scalars are not supported", lineno)
+    if c0 in "\"'":
+        # Quoted scalars are opaque — nothing else to check.
+        if len(v) < 2 or v[-1] != c0:
+            raise _err(f"unterminated quoted string: {v!r}", lineno)
+        return
+    if c0 == "{":
+        raise _err("flow-style maps ({...}) are not supported", lineno)
+    if c0 == "[":
+        if in_flow:
+            raise _err("nested flow collections are not supported", lineno)
+        if not v.endswith("]"):
+            raise _err(f"unclosed flow list: {v!r}", lineno)
+        return  # balanced "[...]"; items are checked per-item in _flow_list
+    if in_flow and any(ch in v for ch in "[]{}"):
+        raise _err("nested flow collections are not supported", lineno)
+    _check_no_mapping_indicator(v, lineno)
+
+
+def _flow_list(s: str, lineno: int) -> list:
+    """Parse [a, b, "c"] — scalars only."""
+    inner = s.strip()[1:-1].strip()
+    if not inner:
+        return []
+    raw_items, cur, in_s, in_d = [], "", False, False
+    for ch in inner:
+        if ch == "'" and not in_d:
+            in_s = not in_s
+            cur += ch
+        elif ch == '"' and not in_s:
+            in_d = not in_d
+            cur += ch
+        elif ch == "," and not in_s and not in_d:
+            raw_items.append(cur)
+            cur = ""
+        else:
+            cur += ch
+    if in_s or in_d:
+        raise _err(f"unterminated quote in flow list: {s}", lineno)
+    raw_items.append(cur)
+    out = []
+    for item in raw_items:
+        _check_value(item, lineno, in_flow=True)
+        out.append(_scalar(item))
+    return out
+
+
+def safe_load(text: str):
+    # items: (line number, indent, content)
+    items = []
+    for lineno, raw in enumerate(text.splitlines(), 1):
+        line = _strip_comment(raw).rstrip()
+        if not line.strip():
+            continue
+        if "\t" in line[: len(line) - len(line.lstrip())]:
+            raise _err("tabs not allowed for indentation", lineno)
+        indent = len(line) - len(line.lstrip(" "))
+        content = line.strip()
+        if content in ("---", "..."):
+            continue
+        items.append((lineno, indent, content))
+    if not items:
+        return None
+    val, pos = _parse_block(items, 0, items[0][1], 0)
+    if pos != len(items):
+        lineno, _, content = items[pos]
+        raise _err(f"unexpected content: {content!r}", lineno)
+    return val
+
+
+def _parse_block(items, pos, indent, depth):
+    if depth > MAX_DEPTH:
+        raise _err(
+            f"maximum nesting depth ({MAX_DEPTH}) exceeded", items[pos][0]
+        )
+    first = items[pos][2]
+    if first == "-" or first.startswith("- "):
+        return _parse_list(items, pos, indent, depth)
+    return _parse_map(items, pos, indent, depth)
+
+
+def _parse_map(items, pos, indent, depth):
+    d: dict = {}
+    while pos < len(items):
+        lineno, ind, line = items[pos]
+        if ind < indent:
+            break
+        if ind > indent:
+            raise _err(f"bad indentation: {line!r}", lineno)
+        if line == "-" or line.startswith("- "):
+            raise _err(f"list item inside mapping: {line!r}", lineno)
+        if line[0] in "&*!":
+            # Anchor/alias/tag where a key was expected — name it.
+            _check_value(line, lineno)
+        m = _KEY_RE.match(line)
+        if not m:
+            raise _err(f"expected 'key: value', got: {line!r}", lineno)
+        key = m.group(1).strip()
+        rest = line[m.end():].strip()
+        pos += 1
+        if key in d:
+            raise _err(f"duplicate key: {key!r}", lineno)
+        if rest:
+            _check_value(rest, lineno)
+            if rest.startswith("["):
+                d[key] = _flow_list(rest, lineno)
+            else:
+                d[key] = _scalar(rest)
+        else:
+            if pos < len(items) and items[pos][1] > indent:
+                val, pos = _parse_block(items, pos, items[pos][1], depth + 1)
+                d[key] = val
+            else:
+                d[key] = None
+    return d, pos
+
+
+def _parse_list(items, pos, indent, depth):
+    lst: list = []
+    while pos < len(items):
+        lineno, ind, line = items[pos]
+        if ind < indent:
+            break
+        if ind > indent:
+            raise _err(f"bad indentation: {line!r}", lineno)
+        if not (line == "-" or line.startswith("- ")):
+            break  # end of list; parent map continues
+        content = line[1:].strip()
+        pos += 1
+        if not content:
+            if pos < len(items) and items[pos][1] > indent:
+                val, pos = _parse_block(items, pos, items[pos][1], depth + 1)
+                lst.append(val)
+            else:
+                lst.append(None)
+            continue
+        if _KEY_RE.match(content):
+            sub = [(lineno, indent + 2, content)]
+            while pos < len(items) and items[pos][1] > indent:
+                sub.append(items[pos])
+                pos += 1
+            val, _ = _parse_map(sub, 0, indent + 2, depth + 1)
+            lst.append(val)
+        elif content.startswith("[") and content.endswith("]"):
+            _check_value(content, lineno)
+            lst.append(_flow_list(content, lineno))
+        else:
+            _check_value(content, lineno)
+            lst.append(_scalar(content))
+    return lst, pos
+
+
+# alias mirroring the PyYAML call sites being replaced
+def load(text: str):
+    return safe_load(text)

adr_drift/rules.py

@@ -0,0 +1,109 @@
+"""Rules: the constraint DSL shared by arch.yaml and ADR files.
+
+A rule is one line:
+
+    forbid-import: <from> -> <to>        # layer/module <from> may not import <to>
+    forbid-pattern: <glob> !~ <regex>    # files matching <glob> must not contain <regex>
+    require-pattern: <glob> =~ <regex>   # files matching <glob> must contain <regex>
+
+<from>/<to> match against layer names or module prefixes ("db.drivers",
+"src/handlers"). "*" is a wildcard. Comments start with "#".
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import fnmatch
+import re
+
+
+@dataclasses.dataclass
+class Rule:
+    kind: str            # forbid-import | forbid-pattern | require-pattern
+    source: str          # "arch.yaml" or "docs/adr/0004-....md"
+    line_no: int = 0
+    raw: str = ""
+    # forbid-import
+    from_pat: str = ""
+    to_pat: str = ""
+    # pattern rules
+    glob: str = ""
+    regex: str = ""
+
+    def describe(self) -> str:
+        if self.kind == "forbid-import":
+            return f"{self.from_pat} must not import {self.to_pat}"
+        if self.kind == "forbid-pattern":
+            return f"{self.glob} must not contain /{self.regex}/"
+        return f"{self.glob} must contain /{self.regex}/"
+
+
+_RULE_RE = re.compile(
+    r"^(forbid-import|forbid-pattern|require-pattern)\s*:\s*(.+?)\s*$")
+
+
+def parse_rule_line(line: str, source: str = "",
+                    line_no: int = 0) -> "Rule | None":
+    """Parse one DSL line. Returns None for blanks/comments/non-rules."""
+    text = line.split("#", 1)[0].strip()
+    if not text:
+        return None
+    m = _RULE_RE.match(text)
+    if not m:
+        return None
+    kind, rest = m.group(1), m.group(2)
+    rule = Rule(kind=kind, source=source, line_no=line_no, raw=line.strip())
+    if kind == "forbid-import":
+        parts = rest.split("->")
+        if len(parts) != 2:
+            raise ValueError(f"bad forbid-import rule: {line.strip()!r} "
+                             f"(want '<from> -> <to>')")
+        rule.from_pat = parts[0].strip()
+        rule.to_pat = parts[1].strip()
+        if not rule.from_pat or not rule.to_pat:
+            raise ValueError(f"bad forbid-import rule: {line.strip()!r}")
+    else:
+        op = "!~" if kind == "forbid-pattern" else "=~"
+        if op not in rest:
+            raise ValueError(f"bad {kind} rule: {line.strip()!r} "
+                             f"(want '<glob> {op} <regex>')")
+        glob, regex = rest.split(op, 1)
+        rule.glob = glob.strip()
+        rule.regex = regex.strip()
+        if not rule.glob or not rule.regex:
+            raise ValueError(f"bad {kind} rule: {line.strip()!r}")
+        try:
+            re.compile(rule.regex)  # validate early
+        except re.error as e:
+            raise ValueError(f"bad {kind} regex in {line.strip()!r}: {e}")
+    return rule
+
+
+def _norm(pat: str) -> str:
+    return pat.replace("/", ".").strip(".")
+
+
+def match_pat(pat: str, value: str) -> bool:
+    """Match a from/to pattern against a layer name or dotted module.
+
+    "db.drivers" matches "db.drivers" and "db.drivers.pg" (prefix with
+    boundary). "*" wildcards supported via fnmatch on both dotted and
+    slash forms.
+    """
+    p, v = _norm(pat), _norm(value)
+    if "*" in p:
+        return (fnmatch.fnmatchcase(v, p)
+                or fnmatch.fnmatchcase(value, pat)
+                or fnmatch.fnmatchcase(v, p.rstrip("*").rstrip(".")))
+    return v == p or v.startswith(p + ".")
+
+
+def match_glob(glob: str, path: str) -> bool:
+    path = path.replace("\\", "/")
+    g = glob.replace("\\", "/")
+    if fnmatch.fnmatchcase(path, g):
+        return True
+    # "**" should also match zero directories: "src/**.py" vs "src/a.py"
+    if "**" in g:
+        return fnmatch.fnmatchcase(path, g.replace("**/", ""))
+    return False

adr_drift/scanner.py

@@ -0,0 +1,97 @@
+"""Import extraction: precise for Python (AST), heuristic for the rest.
+
+Python files get real AST parsing — no regex false positives from comments
+or strings. Other languages (JS/TS/Go/Rust/Java/…) use a regex fallback
+that is documented as heuristic: it can miss exotic forms and may catch
+an import inside a comment. check --strict-py-only disables the fallback.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import re
+import sys
+
+PY_EXTS = {".py"}
+GENERIC_EXTS = {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",
+                ".go", ".rs", ".java", ".rb", ".php"}
+
+# import x.y / from x.y import z / require("x") / import "x" / use x::y …
+_GENERIC_IMPORT_RES = [
+    re.compile(r'^\s*import\s+(?:type\s+)?[{*]?[^"\']*?from\s+["\']([^"\']+)["\']'),
+    re.compile(r'^\s*import\s+["\']([^"\']+)["\']'),
+    re.compile(r'require\(\s*["\']([^"\']+)["\']\s*\)'),
+    re.compile(r'^\s*use\s+([a-zA-Z0-9_:]+)(?:::|\s*[{;])'),
+    re.compile(r'^\s*import\s+\(\s*["\']([^"\']+)["\']'),
+    re.compile(r'^\s*import\s+([a-zA-Z0-9_./@-]+)\s*;?\s*$'),
+]
+
+
+def python_imports(source: str) -> list[tuple[str, int]]:
+    """(module, line_no) via AST. Relative imports resolve to "<local>".
+
+    Raises SyntaxError on unparseable source — callers that know the file
+    path (extract_imports) turn that into a CI-visible warning instead of
+    silently passing the file on every import rule.
+    """
+    found: list[tuple[str, int]] = []
+    tree = ast.parse(source)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for a in node.names:
+                found.append((a.name, node.lineno))
+        elif isinstance(node, ast.ImportFrom):
+            if node.level:
+                found.append(("<local>", node.lineno))
+            elif node.module:
+                found.append((node.module, node.lineno))
+    return found
+
+
+def generic_imports(source: str) -> list[tuple[str, int]]:
+    found: list[tuple[str, int]] = []
+    for i, line in enumerate(source.splitlines(), 1):
+        for rx in _GENERIC_IMPORT_RES:
+            m = rx.search(line)
+            if m:
+                found.append((m.group(1), i))
+                break
+    return found
+
+
+def extract_imports(path: str, source: str | None = None,
+                     strict_py_only: bool = False) -> tuple[list[tuple[str, int]], str]:
+    """Returns (imports, engine) where engine is "ast", "regex", or "none"."""
+    ext = os.path.splitext(path)[1].lower()
+    if source is None:
+        try:
+            with open(path, encoding="utf-8", errors="replace") as f:
+                source = f.read()
+        except OSError:
+            return [], "none"
+    if ext in PY_EXTS:
+        try:
+            return python_imports(source), "ast"
+        except SyntaxError as e:
+            # CI-visible: an unparseable file must not silently pass
+            # every import rule.
+            print(f"warning: {path}: Python syntax error ({e}); "
+                  f"skipping import checks for this file", file=sys.stderr)
+            return [], "ast"
+    if ext in GENERIC_EXTS and not strict_py_only:
+        return generic_imports(source), "regex"
+    return [], "none"
+
+
+def iter_source_files(root: str) -> list[str]:
+    skip_dirs = {".git", "node_modules", "__pycache__", ".venv", "venv",
+                 "dist", "build", ".tox", "vendor"}
+    out: list[str] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in skip_dirs]
+        for fn in filenames:
+            ext = os.path.splitext(fn)[1].lower()
+            if ext in PY_EXTS or ext in GENERIC_EXTS:
+                out.append(os.path.join(dirpath, fn))
+    return sorted(out)

adr_drift-0.1.0.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: adr-drift
+Version: 0.1.0
+Summary: Deterministic architecture tests: keep the codebase honest about its own ADRs.
+Author: Calas Automations Inc.
+License: MIT
+Project-URL: Homepage, https://github.com/calasdan-sketch/adr-drift
+Project-URL: Issues, https://github.com/calasdan-sketch/adr-drift/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ADR Drift
+
+Deterministic architecture tests for any language. ADRs rot the moment they
+merge — this keeps them mechanically true. Define layers and constraints once,
+then `adr-drift check` fails CI when code drifts from the decisions.
+
+## The problem
+
+> "The moment an ADR gets merged, it decays into a passive historical record
+> unless something mechanical forces it to stay alive."
+
+Developers — and now AI coding agents — merge boundary violations because
+nothing checks decisions against code. ArchUnit is Java-only, deptrac is
+PHP-only. ADR Drift is language-agnostic, repo-local, and CI-friendly.
+
+## Install
+
+```bash
+git clone <repo> && cd adr-drift
+pip install .   # provides the `adr-drift` console script
+```
+
+Or run without installing: `python3 -m adr_drift` from the repo root.
+
+## Quick start
+
+```bash
+cd your-repo
+python3 -m adr_drift init      # scaffold arch.yaml + sample ADR from folder layout
+# tighten the rules in arch.yaml, add ## Constraints to your ADRs
+python3 -m adr_drift check     # verify; exit 1 on violations (CI-ready)
+# repo already has legacy violations? grandfather them, then enforce:
+python3 -m adr_drift baseline                    # record current violations
+python3 -m adr_drift check --baseline .adr-baseline.json
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `init` | Infer layers from folder layout, write `arch.yaml` + sample ADR + index |
+| `check` | Verify the repo against `arch.yaml` + every ADR's `## Constraints` (`--baseline FILE` grandfathers recorded violations) |
+| `baseline` | Write current violations to `.adr-baseline.json` (default) for `check --baseline` |
+| `drift --since HEAD~5` | Report violations *introduced* since a git ref, plus violations *fixed* since then (pre-existing ones ignored) |
+| `new "title"` | Create the next-numbered ADR from a template |
+| `index` | Regenerate the one-sentence-per-ADR index (`docs/adr/README.md`) |
+
+## The constraint DSL
+
+Rules live in `arch.yaml` and in any ADR's `## Constraints` section:
+
+```
+forbid-import: handlers -> db.drivers     # layering: handlers may not import drivers
+forbid-pattern: src/**.py !~ \beval\(     # no eval() anywhere in src/
+require-pattern: src/handlers/**.py =~ authenticate\(   # handlers must authenticate
+```
+
+`from`/`to` match layer names or module prefixes (`db.drivers` matches
+`db.drivers.pg`); `*` wildcards supported. Comments start with `#`.
+To-side patterns resolve against layer paths too: in a `src/`-layout repo
+both `db.drivers` and `src.db.drivers` spellings match a `db` layer mapped
+to `src/db/**`.
+
+## How it checks
+
+- **Python** is parsed with the real `ast` — no regex false positives from
+  comments or strings.
+- **JS/TS/Go/Rust/Java/Ruby/PHP** use a heuristic regex import extractor
+  (documented as such; `--strict-py-only` disables it).
+- `drift` compares violations at HEAD against the base ref via `git show` —
+  it never touches your working tree, and `git blame` tags each new
+  violation with its introducing commit.
+
+## CI
+
+```yaml
+- run: python3 -m adr_drift check --format json --fail-on violations
+```
+
+`--fail-on none` reports without failing. JSON output is stable for tooling.
+
+## Honest limits
+
+- The regex fallback for non-Python languages is heuristic — it can miss
+  exotic import forms. Python is precise; everything else is best-effort.
+- `drift` needs a git repo; `check` works anywhere.
+- Rules are only as good as the constraints you write — `init` scaffolds,
+  you tighten.
+
+## Tests
+
+55/55 pass: `python3 -m unittest discover -s tests`

adr_drift-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+adr_drift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adr_drift/__main__.py,sha256=MHKZ_ae3fSLGTLUUMOx15fWdeOnJSHhq-zslRP5F5Lc,79
+adr_drift/cli.py,sha256=8OkgGEzxlpksdLU8UIsc1gpXvBwGk2SUKzab4lNf-S4,13855
+adr_drift/config.py,sha256=MUQR2bGWMqvUuAt6KT-KeUttvN9Dcx3kX8a3gRUU8wk,3087
+adr_drift/engine.py,sha256=Bzyfeaxrf8FzvLOWNyUwl0sXV2PPGMJehkJYasv8qDw,5637
+adr_drift/githelp.py,sha256=Z5qCV74dv11qAvl-FwdBKJkjKVT_RgDPj21_GWgbx4I,2040
+adr_drift/miniyaml.py,sha256=bDpXNkei59wFIOd3Jf7Z_gqVXHI1RpqtUxpRT3a1yCU,9170
+adr_drift/rules.py,sha256=bXjGrir5YyXw-ssnpv299gghgZR7QytLRsU8H67uZmM,3762
+adr_drift/scanner.py,sha256=2VIrjSO9UDeFAiIoGmfgorRKEjwIyfCFyNHhhPPmYBA,3703
+adr_drift-0.1.0.dist-info/licenses/LICENSE,sha256=f-qFLkEfvZidBgKv2YINOOKS7Trk_gj1c6Cy718D8F0,1079
+adr_drift-0.1.0.dist-info/METADATA,sha256=KdZ2ZLbnPUo_RfkfwL4dcqBaIMbjocq2oQCxUBxAz3k,3981
+adr_drift-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+adr_drift-0.1.0.dist-info/entry_points.txt,sha256=94VmW9mcrKT61dzxWxHtsT4VLAJ45QXnNsPb1GjvHFw,49
+adr_drift-0.1.0.dist-info/top_level.txt,sha256=gS9Ec1NqWgjm8y8Ecw4wCCoJCtF2kvBjfM5Sgrv5xf4,10
+adr_drift-0.1.0.dist-info/RECORD,,

adr_drift-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
+

adr_drift-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+adr-drift = adr_drift.cli:main

adr_drift-0.1.0.dist-info/licenses/LICENSE

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

adr_drift-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+adr_drift