codd-dev 0.2.0a1__py3-none-any.whl

codd/verifier.py

@@ -0,0 +1,426 @@
+"""CoDD verifier for typecheck and test validation with design traceability."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shlex
+import subprocess
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from codd.config import load_project_config
+
+
+@dataclass(frozen=True)
+class TypecheckError:
+    file_path: str
+    line: int
+    col: int
+    code: str
+    message: str
+
+
+@dataclass(frozen=True)
+class TypecheckResult:
+    success: bool
+    error_count: int
+    errors: tuple[TypecheckError, ...]
+
+
+@dataclass(frozen=True)
+class TestFailure:
+    test_file_path: str
+    test_name: str
+    failure_messages: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class TestResult:
+    success: bool
+    total: int
+    passed: int
+    failed: int
+    skipped: int
+    failures: tuple[TestFailure, ...]
+
+
+@dataclass(frozen=True)
+class DesignRef:
+    node_id: str
+    doc_path: str
+    trace_source: str
+    source_file: str
+
+
+@dataclass(frozen=True)
+class VerifyResult:
+    success: bool
+    typecheck: TypecheckResult
+    tests: TestResult
+    design_refs: tuple[DesignRef, ...]
+    warnings: tuple[str, ...]
+    report_path: str
+
+
+class VerifyPreflightError(Exception):
+    """Raised when the target project is missing required build/test inputs."""
+
+
+DEFAULT_VERIFY_CONFIG: dict[str, Any] = {
+    "typecheck_command": "npx tsc --noEmit",
+    "test_command": "npx jest --ci --json --outputFile=.codd/test-results.json",
+    "test_output_file": ".codd/test-results.json",
+    "report_output": "docs/test/verify_report.md",
+    "test_pattern": "tests/unit/sprint_{sprint}/**/*.test.ts",
+}
+
+GENERATED_FROM_RE = re.compile(
+    r"^//\s*@generated-from:\s*(?P<path>.+?)\s*\((?P<node_id>[^)]+)\)\s*$",
+    re.MULTILINE,
+)
+TSC_ERROR_RE = re.compile(
+    r"^(?P<file>[^(]+)\((?P<line>\d+),(?P<col>\d+)\):\s*error\s+(?P<code>TS\d+):\s*(?P<message>.+)$",
+    re.MULTILINE,
+)
+TS_IMPORT_RE = re.compile(
+    r"^\s*import\s+.*?\s+from\s+['\"](?P<path>[^'\"]+)['\"]",
+    re.MULTILINE,
+)
+
+
+def _propagate_targets(design_refs: tuple[DesignRef, ...]) -> tuple[str, ...]:
+    return tuple(dict.fromkeys(ref.node_id for ref in design_refs))
+
+
+def run_verify(
+    project_root: Path,
+    sprint: int | None = None,
+) -> VerifyResult:
+    """Run build + test verification and trace failures to design documents."""
+    config = _load_project_config(project_root)
+    verifier = _Verifier(project_root.resolve(), config)
+    return verifier.run(sprint)
+
+
+def _load_project_config(project_root: Path) -> dict[str, Any]:
+    """Load merged CoDD config and extract the verify section."""
+    config = dict(DEFAULT_VERIFY_CONFIG)
+    project_config = load_project_config(project_root.resolve())
+    verify_config = project_config.get("verify", {})
+    if verify_config is None:
+        return config
+    if not isinstance(verify_config, dict):
+        raise ValueError("codd verify config must be a mapping")
+    config.update(verify_config)
+    return config
+
+
+class _Verifier:
+    def __init__(self, project_root: Path, config: dict[str, Any]):
+        self.project_root = project_root
+        self.config = config
+
+    def run(self, sprint: int | None = None) -> VerifyResult:
+        warnings: list[str] = []
+        self._preflight_check()
+
+        (self.project_root / ".codd").mkdir(exist_ok=True)
+
+        typecheck_result = self._run_typecheck()
+        test_result = self._run_tests(sprint)
+
+        design_refs: list[DesignRef] = []
+        if not typecheck_result.success:
+            refs, new_warnings = self._trace_from_typecheck_errors(typecheck_result.errors)
+            design_refs.extend(refs)
+            warnings.extend(new_warnings)
+        if not test_result.success:
+            refs, new_warnings = self._trace_from_test_failures(test_result.failures)
+            design_refs.extend(refs)
+            warnings.extend(new_warnings)
+
+        unique_refs: list[DesignRef] = []
+        seen_ref_keys: set[tuple[str, str]] = set()
+        for ref in design_refs:
+            key = (ref.node_id, ref.source_file)
+            if key in seen_ref_keys:
+                continue
+            seen_ref_keys.add(key)
+            unique_refs.append(ref)
+
+        unique_warnings = tuple(dict.fromkeys(warnings))
+        success = typecheck_result.success and test_result.success
+        interim = VerifyResult(
+            success=success,
+            typecheck=typecheck_result,
+            tests=test_result,
+            design_refs=tuple(unique_refs),
+            warnings=unique_warnings,
+            report_path="",
+        )
+        report_path = self._generate_report(interim)
+        return VerifyResult(
+            success=success,
+            typecheck=typecheck_result,
+            tests=test_result,
+            design_refs=tuple(unique_refs),
+            warnings=unique_warnings,
+            report_path=report_path,
+        )
+
+    def _preflight_check(self) -> None:
+        missing = []
+        for name in ("package.json", "tsconfig.json", "node_modules"):
+            if not (self.project_root / name).exists():
+                missing.append(name)
+        if missing:
+            raise VerifyPreflightError(f"Missing: {', '.join(missing)}. Run npm install first.")
+
+    def _run_typecheck(self) -> TypecheckResult:
+        proc = subprocess.run(
+            shlex.split(self.config["typecheck_command"]),
+            cwd=str(self.project_root),
+            env=os.environ.copy(),
+            capture_output=True,
+            text=True,
+        )
+        output = proc.stdout + proc.stderr
+        errors = tuple(
+            TypecheckError(
+                file_path=match.group("file").strip(),
+                line=int(match.group("line")),
+                col=int(match.group("col")),
+                code=match.group("code"),
+                message=match.group("message").strip(),
+            )
+            for match in TSC_ERROR_RE.finditer(output)
+        )
+        return TypecheckResult(
+            success=proc.returncode == 0,
+            error_count=len(errors),
+            errors=errors,
+        )
+
+    def _run_tests(self, sprint: int | None) -> TestResult:
+        output_path = self._resolve_path(self.config.get("test_output_file", ".codd/test-results.json"))
+        if output_path.exists():
+            output_path.unlink()
+
+        command = shlex.split(self.config["test_command"])
+        if sprint is not None:
+            pattern = self.config.get("test_pattern", "tests/unit/sprint_{sprint}/**/*.test.ts")
+            command.append(f"--testPathPattern={pattern.format(sprint=sprint)}")
+
+        proc = subprocess.run(
+            command,
+            cwd=str(self.project_root),
+            env=os.environ.copy(),
+            capture_output=True,
+            text=True,
+        )
+        data = self._load_test_output(output_path, proc.stdout)
+
+        failures: list[TestFailure] = []
+        for suite in data.get("testResults", []):
+            if suite.get("status") != "failed":
+                continue
+            for assertion in suite.get("assertionResults", []):
+                if assertion.get("status") != "failed":
+                    continue
+                failures.append(
+                    TestFailure(
+                        test_file_path=str(suite.get("testFilePath") or suite.get("name") or ""),
+                        test_name=str(assertion.get("fullName", "")),
+                        failure_messages=tuple(assertion.get("failureMessages", [])),
+                    )
+                )
+
+        return TestResult(
+            success=bool(data.get("success", False) and proc.returncode == 0),
+            total=int(data.get("numTotalTests", 0)),
+            passed=int(data.get("numPassedTests", 0)),
+            failed=int(data.get("numFailedTests", 0)),
+            skipped=int(data.get("numPendingTests", 0)),
+            failures=tuple(failures),
+        )
+
+    def _load_test_output(self, output_path: Path, stdout: str) -> dict[str, Any]:
+        if output_path.exists():
+            payload = json.loads(output_path.read_text(encoding="utf-8"))
+            if not isinstance(payload, dict):
+                raise ValueError("jest output must be a JSON object")
+            return payload
+
+        raw = stdout.strip()
+        if raw:
+            payload = json.loads(raw)
+            if not isinstance(payload, dict):
+                raise ValueError("jest stdout JSON must be an object")
+            return payload
+
+        return {
+            "success": False,
+            "numTotalTests": 0,
+            "numPassedTests": 0,
+            "numFailedTests": 0,
+            "numPendingTests": 0,
+            "testResults": [],
+        }
+
+    def _trace_from_typecheck_errors(
+        self, errors: tuple[TypecheckError, ...]
+    ) -> tuple[list[DesignRef], list[str]]:
+        refs: list[DesignRef] = []
+        warnings: list[str] = []
+        for error in errors:
+            ts_file = Path(error.file_path)
+            if not ts_file.is_absolute():
+                ts_file = self.project_root / ts_file
+            new_refs, new_warnings = self._extract_design_refs(ts_file, "typecheck_error")
+            refs.extend(new_refs)
+            warnings.extend(new_warnings)
+        return refs, warnings
+
+    def _trace_from_test_failures(
+        self, failures: tuple[TestFailure, ...]
+    ) -> tuple[list[DesignRef], list[str]]:
+        refs: list[DesignRef] = []
+        warnings: list[str] = []
+        for failure in failures:
+            test_file = Path(failure.test_file_path)
+            if not test_file.is_absolute():
+                test_file = self.project_root / test_file
+            if not test_file.exists() or test_file.is_dir():
+                continue
+
+            content = test_file.read_text(encoding="utf-8")
+            for import_match in TS_IMPORT_RE.finditer(content):
+                import_path = import_match.group("path")
+                if not import_path.startswith("."):
+                    continue
+                for candidate in self._resolve_import_candidates(test_file, import_path):
+                    if not candidate.exists():
+                        continue
+                    new_refs, new_warnings = self._extract_design_refs(candidate, "test_failure")
+                    refs.extend(new_refs)
+                    warnings.extend(new_warnings)
+                    break
+        return refs, warnings
+
+    def _resolve_import_candidates(self, test_file: Path, import_path: str) -> tuple[Path, ...]:
+        base = (test_file.parent / import_path).resolve()
+        candidates = [base]
+        if base.suffix:
+            candidates.extend([base.with_suffix(".ts"), base.with_suffix(".tsx")])
+        else:
+            candidates.extend(
+                [
+                    base.with_suffix(".ts"),
+                    base.with_suffix(".tsx"),
+                    base / "index.ts",
+                    base / "index.tsx",
+                ]
+            )
+
+        unique: list[Path] = []
+        seen: set[Path] = set()
+        for candidate in candidates:
+            if candidate in seen:
+                continue
+            seen.add(candidate)
+            unique.append(candidate)
+        return tuple(unique)
+
+    def _extract_design_refs(
+        self, ts_file: Path, trace_source: str
+    ) -> tuple[list[DesignRef], list[str]]:
+        warnings: list[str] = []
+        refs: list[DesignRef] = []
+        if not ts_file.exists():
+            return refs, warnings
+
+        try:
+            header = "\n".join(ts_file.read_text(encoding="utf-8").splitlines()[:30])
+        except OSError:
+            return refs, warnings
+
+        matches = list(GENERATED_FROM_RE.finditer(header))
+        if not matches:
+            warnings.append(f"No @generated-from header in {ts_file} — manual review required")
+            return refs, warnings
+
+        for match in matches:
+            refs.append(
+                DesignRef(
+                    node_id=match.group("node_id"),
+                    doc_path=match.group("path"),
+                    trace_source=trace_source,
+                    source_file=str(ts_file),
+                )
+            )
+        return refs, warnings
+
+    def _generate_report(self, result: VerifyResult) -> str:
+        report_path = self._resolve_path(self.config.get("report_output", "docs/test/verify_report.md"))
+        report_path.parent.mkdir(parents=True, exist_ok=True)
+
+        lines = [
+            "# CoDD Verify Report",
+            "",
+            f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+            "",
+            f"## Result: {'PASS' if result.success else 'FAIL'}",
+            "",
+            "## Typecheck",
+            f"- Status: {'PASS' if result.typecheck.success else 'FAIL'}",
+            f"- Errors: {result.typecheck.error_count}",
+            "",
+            "## Tests",
+            f"- Status: {'PASS' if result.tests.success else 'FAIL'}",
+            (
+                f"- Total: {result.tests.total} | Passed: {result.tests.passed} | "
+                f"Failed: {result.tests.failed} | Skipped: {result.tests.skipped}"
+            ),
+        ]
+
+        if result.typecheck.errors:
+            lines.extend(["", "### Typecheck Errors"])
+            for error in result.typecheck.errors:
+                lines.append(
+                    f"- `{error.file_path}:{error.line}:{error.col}` {error.code}: {error.message}"
+                )
+
+        if result.tests.failures:
+            lines.extend(["", "### Test Failures"])
+            for failure in result.tests.failures:
+                lines.append(f"- `{failure.test_file_path}` - {failure.test_name}")
+
+        if result.design_refs:
+            lines.extend(["", "## Design Documents to Review"])
+            for ref in result.design_refs:
+                lines.append(
+                    f"- **{ref.node_id}** -> `{ref.doc_path}` (from `{ref.source_file}`, via {ref.trace_source})"
+                )
+            targets = _propagate_targets(result.design_refs)
+            if targets:
+                lines.extend(["", "## Suggested Propagation Targets"])
+                for target in targets:
+                    lines.append(f"- `{target}`")
+
+        if result.warnings:
+            lines.extend(["", "## Warnings"])
+            for warning in result.warnings:
+                lines.append(f"- {warning}")
+
+        report_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        return str(report_path)
+
+    def _resolve_path(self, raw_path: str) -> Path:
+        path = Path(raw_path)
+        if path.is_absolute():
+            return path
+        return self.project_root / path

codd_dev-0.2.0a1.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: codd-dev
+Version: 0.2.0a1
+Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
+Project-URL: Homepage, https://github.com/yohey-w/shogun-codd
+Project-URL: Repository, https://github.com/yohey-w/shogun-codd
+Project-URL: Issues, https://github.com/yohey-w/shogun-codd/issues
+Author-email: Yohei Watanabe <yohey-w@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: change-impact,claude-code,dependency-graph,plugin,software-engineering
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: mcp
+Provides-Extra: scan
+Requires-Dist: tree-sitter-java>=0.22; extra == 'scan'
+Requires-Dist: tree-sitter-python>=0.22; extra == 'scan'
+Requires-Dist: tree-sitter-typescript>=0.22; extra == 'scan'
+Requires-Dist: tree-sitter>=0.22; extra == 'scan'
+Description-Content-Type: text/markdown
+
+# CoDD — Coherence-Driven Development
+
+**CoDD keeps AI-built systems coherent as requirements change.**
+
+Give CoDD your requirements and constraints. AI generates the design top-down, derives implementation and test strategy from those artifacts, and traces change impact across a dependency graph — so nothing falls out of sync.
+
+> *Harnesses tell agents how to work. CoDD keeps artifacts coherent.*
+
+```
+Harness (CLAUDE.md, AGENTS.md, Hooks, Skills)  ← Rules, guardrails, flow
+  └─ CoDD (methodology)                        ← Operates on the harness flow
+       └─ Design docs (docs/*.md)              ← Artifacts CoDD generates and maintains
+```
+
+**Public Alpha** — `pip install codd-dev` — init / scan / impact / validate are stable today.
+
+## The Problem
+
+AI can generate code from specs. But what happens when requirements change mid-project?
+
+- Which design docs are affected?
+- Which tests need updating?
+- Which API contracts broke?
+- Did anyone forget to update the database migration?
+
+Spec-driven tools help you write specs first. They don't track what happens when those specs change. That's where CoDD comes in.
+
+### Why not just AGENTS.md or hooks?
+
+AGENTS.md, CLAUDE.md, and hooks are **harness infrastructure** — they tell agents how to behave. CoDD is a **coherence layer** that sits on top of any harness and keeps design artifacts, implementation, and tests in sync when requirements change. CoDD is harness-agnostic: it works with Claude Code, GitHub Copilot, Cursor, or any agent framework.
+
+## Core Principle: Derive, Don't Configure
+
+**Upstream artifacts + best practices = downstream is self-evident.**
+
+- `system_design.md` says "Next.js + Supabase" → test strategy is vitest + Playwright. No config needed.
+- `api_design.md` says "FastAPI" → pytest + httpx. No config needed.
+- Requirements change → `codd impact` shows exactly what's affected.
+
+You define requirements and constraints. AI derives everything else.
+
+## How It Works
+
+```
+Phase 1: Requirements (human)        ─┐
+Phase 2: Design generation (AI)       │ V-Model left side
+Phase 3: Scan (auto)                  │
+Phase 4: Implementation (AI)         ─┘
+Phase 5: Verification (AI + human)   ─── V-Model right side
+Phase 6: Change impact analysis      ─┐
+Phase 7: Change propagation           │ Continuous coherence
+Phase 8: Customer review             ─┘
+```
+
+Design docs are generated in **Wave order** — each wave depends on the previous:
+
+```
+Wave 1: Acceptance criteria + ADR        (← requirements only)
+Wave 2: System design                    (← req + Wave 1)
+Wave 3: Database design + API design     (← req + Wave 1-2)
+Wave 4: UI/UX design                     (← req + Wave 1-3)
+Wave 5: Implementation plan              (← all above)
+```
+
+Verification runs bottom-up (IPA Common Frame):
+```
+Unit tests      ← verifies detailed design
+Integration     ← verifies system design
+E2E / System    ← verifies requirements + acceptance criteria
+```
+
+## Three Layers (Don't Confuse Them)
+
+```
+Harness (CLAUDE.md, Hooks, Skills)   ← Rules, guardrails, flow
+  └─ CoDD (methodology)              ← Operates on the harness flow
+       └─ Design docs (docs/*.md)    ← Artifacts CoDD generates and maintains
+```
+
+- **Harness** = how agents work (any harness: Claude Code, Copilot, Cursor, etc.)
+- **CoDD** = how artifacts stay coherent across changes
+- **Docs** = what CoDD produces and maintains
+
+CoDD is **harness-agnostic**. It runs on top of whatever agent framework you use.
+
+## Quick Start
+
+```bash
+# Install
+pip install codd-dev
+
+# Initialize
+codd init --project-name "my-project" --language "typescript"
+
+# Scan — build dependency graph from frontmatter
+codd scan
+
+# Impact — what breaks if I change this?
+codd impact --diff HEAD~1
+```
+
+## Real Project: Osato LMS
+
+CoDD was dogfooded on a production LMS (Learning Management System). All design documents, implementation code, and tests were generated by AI following CoDD's workflow. No manual review by the client.
+
+```
+docs/
+├── requirements/       # What to build (client agreement, SSoT)
+├── design/             # How to build it (system design, API, DB, UI)
+├── detailed_design/    # Module-level specs
+├── plan/               # WBS, schedule, RACI
+├── governance/         # ADR, meeting minutes, change requests
+├── test/               # Acceptance criteria, test plans
+├── operations/         # Runbooks, monitoring design
+└── infra/              # Infrastructure specs
+```
+
+Every doc has CoDD frontmatter declaring its dependencies:
+
+```yaml
+---
+codd:
+  node_id: "design:api-design"
+  depends_on:
+    - id: "design:system-design"
+      relation: derives_from
+    - id: "req:lms-requirements-v2.0"
+      relation: implements
+---
+```
+
+When the requirements changed mid-project, `codd impact` identified exactly which design docs, API endpoints, and test cases needed updating — and AI fixed them automatically.
+
+## How CoDD Differs from Spec Kit / OpenSpec
+
+|  | Spec Kit | OpenSpec | **CoDD** |
+|--|----------|---------|----------|
+| Write specs first | Yes | Yes | Yes |
+| AI generates code from specs | Yes | Yes | Yes |
+| **Change propagation** | No | No | **Dependency graph + impact analysis** |
+| **Derive test strategy from architecture** | No | No | **Automatic (derive, don't configure)** |
+| **V-Model verification** | No | No | **Unit → Integration → E2E** |
+| **Impact analysis on change** | No | No | **codd impact --diff HEAD~1** |
+| Harness-agnostic | GitHub Copilot focused | Multi-agent | **Any harness** |
+
+**Spec Kit and OpenSpec answer "how do I start?" CoDD answers "how do I keep going when things change?"**
+
+## What's Available Now (v0.2.0-alpha.1)
+
+| Command | Status | What it does |
+|---------|--------|-------------|
+| `codd init` | **Stable** | Initialize CoDD in any project |
+| `codd scan` | **Stable** | Build dependency graph from frontmatter |
+| `codd impact` | **Stable** | Analyze change impact (Green/Amber/Gray bands) |
+| `codd validate` | **Alpha** | Check frontmatter integrity and graph consistency |
+| `codd generate` | Experimental | Generate design docs in Wave order |
+| `codd plan` | Experimental | Wave execution status and auto-initialization |
+| `codd verify` | Experimental | V-Model verification (typecheck + tests → design tracing) |
+| `codd implement` | Experimental | Design-to-code generation |
+
+### Alpha Scope: What We Promise / What We Don't
+
+| We promise | We don't promise (yet) |
+|------------|----------------------|
+| Frontmatter-based dependency graph works | Full semantic dependency types beyond Wave order |
+| `codd impact` correctly identifies affected nodes | Automatic fix of affected nodes |
+| `codd validate` catches broken references and cycles | Exhaustive validation of all edge cases |
+| Harness-agnostic (no vendor lock-in) | Turnkey integrations for every harness |
+| Derivation principle: architecture → test strategy | Fully automated end-to-end generation pipeline |
+| MIT license, stable CLI interface for core commands | API stability for experimental commands |
+
+## Frontmatter is the Single Source of Truth
+
+CoDD uses YAML frontmatter in Markdown files to declare dependencies. `graph.db` is a derived cache — regenerated on every `codd scan`. No separate config files to maintain.
+
+```yaml
+---
+codd:
+  node_id: "design:system-design"
+  type: design
+  depends_on:
+    - id: "req:lms-requirements-v2.0"
+      relation: implements
+  conventions:
+    - targets: ["db:rls_policies"]
+      reason: "Tenant isolation is non-negotiable"
+---
+```
+
+## Real-World Example: Derive, Don't Configure
+
+```
+system_design.md says "Next.js + Supabase"
+→ Test strategy: vitest (unit) + Playwright (E2E). No config needed.
+
+system_design.md says "FastAPI + Python"
+→ Test strategy: pytest (unit/integration) + httpx (API). No config needed.
+
+system_design.md says "CLI tool in Go"
+→ Test strategy: go test (unit/integration). No config needed.
+```
+
+The architecture determines the test strategy. CoDD derives it — you don't configure it.
+
+## Roadmap
+
+- [ ] Semantic dependency types (requires, affects, verifies, implements)
+- [ ] `codd verify` — full docs ↔ code ↔ tests coherence check
+- [ ] Multi-agent integration examples (Claude Code, Copilot, Cursor)
+- [ ] VS Code extension for impact visualization
+
+## License
+
+MIT

codd_dev-0.2.0a1.dist-info/RECORD

@@ -0,0 +1,18 @@
+codd/__init__.py,sha256=AfzNT2ZTbjpX8ZkkmfnaQ-z9Inc87NZQJembUY_ix4Q,73
+codd/cli.py,sha256=3grEHt9wrVpS9nVf7hg655cbv0XIt-WEOFkaLXu1Uz8,12587
+codd/config.py,sha256=oq05-BwllvyQvSyxjUoPqpw37-KVPU3Ioectl9Rclyw,1909
+codd/defaults.yaml,sha256=Z43uS1bI00FO6-q37Qwr_pTkydgX4MOqA_njDmad7dk,512
+codd/generator.py,sha256=qOq2jOoD0lPwTJpr10uRdt62wcGk8ibi6sLZBp8rwCI,24238
+codd/graph.py,sha256=DnPID8kEnHsAMuSUq6-5H6P_145hBw295MtWWaJ14jc,10506
+codd/hooks.py,sha256=qceJXLYvRGf7gDehKvth5HYpEy51xjoBtYcDPLXVy3I,3306
+codd/implementer.py,sha256=BlOHrgGNHGrZhbhxg1PDthPj1BH1a4ViiGO3Jx217xg,33576
+codd/planner.py,sha256=Cs3ewsOMajcOFw1YkRK54eLvCY1nd4C6uj1CLYPvHp4,22582
+codd/propagate.py,sha256=k3UHInq7gSEafnlby1x-MaPkl_MzCcsIoNVrHhGPoSc,11869
+codd/scanner.py,sha256=5cSIkrs9ozgPWVXEummbAEgTBwYNcxA4icxktrSBQNQ,18684
+codd/validator.py,sha256=VXuvtqh4wjjxOlhWhkrwEke7OFOgfg5YE3sWXqHQkDg,16150
+codd/verifier.py,sha256=Jp2ssijlKxbCzna6l9wsjKcXvu-UbNb9J5fSmH9WbsY,14645
+codd_dev-0.2.0a1.dist-info/METADATA,sha256=jtt2DeB0kUkhYXuJfi-xk8BaTeFTht0v7qZNFmYunBQ,9560
+codd_dev-0.2.0a1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+codd_dev-0.2.0a1.dist-info/entry_points.txt,sha256=UDAbmLzJtylD_Ctz4DXjHbpVTAdgNTKOtp0EEYTR320,39
+codd_dev-0.2.0a1.dist-info/licenses/LICENSE,sha256=lxe1LIqG7R8QrE4jJMD1IZvRzHTtcE5RnJHy75tSKz8,1062
+codd_dev-0.2.0a1.dist-info/RECORD,,

codd_dev-0.2.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

codd_dev-0.2.0a1.dist-info/entry_points.txt

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