custos-code 0.0.1__py3-none-any.whl

custos_code/verdicts.py

@@ -0,0 +1,296 @@
+"""Runs the ladder: rules -> (rerun) -> judge, and enforces the invariants at the boundary.
+
+This is the only place that assembles VerdictRecords for a session. It asserts that no
+judge-produced record is `contradicted`, that every `confirmed` carries evidence or a state
+check, and that unsettled claims come back as `unwitnessed` rather than being dropped.
+
+Escalation rule: a rule's verdict stands unless it is a low-confidence `unwitnessed` that the
+rule itself marked as semantic (tier 4). Those, and claims with no rule at all, go to the judge,
+which can only turn `unwitnessed` into `confirmed` — never the other way, and never into
+`contradicted`. So adding a judge can only ever add evidence, not remove a deterministic finding.
+
+Owner: Oliver.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import subprocess
+
+from . import claims as claims_mod
+from . import parsers
+from . import rerun as rerun_mod
+from .judge import Backend, window_for_all
+from .models import Claim, ClaimType, EventKind, LedgerEvent, Verdict, VerdictRecord
+from .rules import check as rules_check
+
+# Claim types that only a tool log can witness. Edits, commits and deletions survive in state, so
+# they stay settleable on a class-R record; these do not.
+NEEDS_TOOL_LOG = frozenset(
+    {
+        ClaimType.RUN_CMD,
+        ClaimType.RUN_TESTS,
+        ClaimType.BUILD,
+        ClaimType.DEPLOY,
+        ClaimType.READ,
+        ClaimType.OBSERVED_OUTPUT,
+        ClaimType.VERIFY,
+    }
+)
+
+
+def known_incomplete(ledger: list[LedgerEvent]) -> str | None:
+    """The adapter's own statement that this record has no tool log (see adapters/state.py)."""
+    for event in ledger:
+        if event.kind is EventKind.META and (event.input or {}).get("event") == "no_tool_log":
+            return str((event.input or {}).get("note") or "the record has no tool log")
+    return None
+
+
+def _enforce(rec: VerdictRecord) -> VerdictRecord:
+    if rec.method == "judge" and rec.verdict == Verdict.CONTRADICTED:
+        raise AssertionError("invariant 3: the judge cannot emit contradicted")
+    if (
+        rec.verdict == Verdict.CONFIRMED
+        and not rec.evidence
+        and rec.method not in ("state", "rerun")
+    ):
+        raise AssertionError("confirmed without evidence or a state check")
+    return rec
+
+
+def _escalates(rec: VerdictRecord | None) -> bool:
+    """True when the judge could add something a rule could not."""
+    if rec is None:
+        return True
+    return rec.verdict == Verdict.UNWITNESSED and rec.tier >= 4
+
+
+def apply_reruns(
+    claims: list[Claim], records: list[VerdictRecord], ledger: list[LedgerEvent],
+) -> list[VerdictRecord]:
+    """Settle open test claims from claim-bound, numbered harness reruns.
+
+    Launching remains in the Stop hook so read-only audits never execute repository code.
+    A result cannot stand in for a different claim/session or survive later tool activity.
+    Legacy events without a launch boundary remain available to the judge, not this rule.
+    """
+    settled = []
+    for claim, rec in zip(claims, records, strict=True):
+        ctype = claim.type
+        if ctype == ClaimType.OTHER:
+            ctype = claims_mod.classify(claim.text) or ClaimType.OTHER
+        if ctype not in _RERUNNABLE or claim.polarity != "did" or rec.verdict not in (
+            Verdict.UNWITNESSED, Verdict.UNRECORDED,
+        ):
+            settled.append(rec)
+            continue
+        candidates = []
+        for event in ledger:
+            meta = event.input or {}
+            boundary = meta.get("report_seq")
+            if (event.kind != EventKind.RERUN or event.tool != "rerun_tests"
+                    or event.session_id != claim.session_id or event.flags.sidechain
+                    or meta.get("claim_id") != claim.id or meta.get("claim_text") != claim.text
+                    or meta.get("claim_kind", "run_tests") != ctype.value
+                    or not isinstance(boundary, int)
+                    or event.seq <= boundary):
+                continue
+            if any(e.session_id == claim.session_id and not e.flags.sidechain
+                   and e.kind in (EventKind.CALL, EventKind.RESULT) and e.seq > boundary
+                   for e in ledger):
+                continue
+            candidates.append(event)
+        if not candidates:
+            settled.append(rec)
+            continue
+        event = max(candidates, key=lambda e: e.seq)
+        parsed = parsers.parse(event.output or "", event.exit_code)
+        verdict = Verdict.UNRECORDED
+        why = "Tier 3 re-run has no complete, recognised test outcome."
+        qualifier = None
+        flags = event.flags
+        if not (flags.timed_out or flags.interrupted or flags.truncated or flags.piped):
+            if ctype == ClaimType.BUILD:
+                if event.exit_code == 0 and not flags.error:
+                    verdict = Verdict.CONFIRMED
+                    why = "Tier 3 build completed successfully."
+                elif event.exit_code not in (None, 0, 126, 127):
+                    verdict = Verdict.CONTRADICTED
+                    why = f"Tier 3 build failed (exit {event.exit_code})."
+            elif parsed is not None and event.exit_code is not None:
+                if parsed.failed or parsed.errors or parsed.collected == 0:
+                    verdict = Verdict.CONTRADICTED
+                    why = (f"Tier 3 {parsed.runner}: {parsed.passed} passed, "
+                           f"{parsed.failed} failed, {parsed.errors} errors"
+                           + ("; no tests collected." if parsed.collected == 0 else "."))
+                elif event.exit_code == 0 and not flags.error and parsed.passed > 0:
+                    verdict = Verdict.CONFIRMED
+                    why = f"Tier 3 {parsed.runner}: {parsed.passed} passed, 0 failed."
+                    counts = [o for o in claim.objects if o.isdigit()]
+                    if counts and any(int(n) != parsed.passed for n in counts):
+                        verdict = Verdict.QUALIFIED
+                        qualifier = f"{', '.join(counts)} claimed, {parsed.passed} passed"
+        settled.append(_enforce(VerdictRecord(
+            claim_id=claim.id, verdict=verdict, tier=3, method="rerun",
+            confidence=0.9, evidence=[event.seq], rationale=why, qualifier=qualifier,
+        )))
+    return settled
+
+
+def run(
+    claims: list[Claim],
+    ledger: list[LedgerEvent],
+    repo_root: str | None,
+    backend: Backend | None = None,
+) -> list[VerdictRecord]:
+    settled: dict[str, VerdictRecord] = {}
+    pending: list[Claim] = []
+    for claim in claims:
+        found = rules_check(claim, ledger, repo_root)
+        if _escalates(found):
+            pending.append(claim)
+        rec = (
+            found
+            if found is not None
+            else VerdictRecord(
+                claim_id=claim.id,
+                verdict=Verdict.UNWITNESSED,
+                tier=4,
+                method="rule",
+                confidence=0.5,
+                evidence=[],
+                rationale="No deterministic rule applies to this claim type.",
+            )
+        )
+        settled[claim.id] = _enforce(rec)
+
+    if backend is not None and pending:
+        win = window_for_all(ledger, pending)
+        for jrec in backend.judge(pending, win):
+            if jrec.verdict == Verdict.CONFIRMED:  # the judge may only upgrade unwitnessed
+                settled[jrec.claim_id] = _enforce(jrec)
+            else:
+                prev = settled[jrec.claim_id]
+                prev.rationale = jrec.rationale or prev.rationale
+                prev.method = "judge"
+                prev.tier = 4
+
+    note = known_incomplete(ledger)
+    if note:
+        for claim in claims:
+            rec = settled[claim.id]
+            if rec.verdict is Verdict.UNWITNESSED and claim.type in NEEDS_TOOL_LOG:
+                rec.verdict = Verdict.UNRECORDED
+                rec.rationale = f"{note}; this claim needs one."
+    return apply_reruns(claims, [settled[c.id] for c in claims], ledger)
+
+
+def summary(records: list[VerdictRecord]) -> dict[str, int]:
+    s = {v.value: 0 for v in Verdict}
+    for r in records:
+        s[r.verdict.value] += 1
+    return s
+
+
+# ---------------------------------------------------------------------------------------------
+# Tier 3 gating: when re-execution is worth launching at all.
+#
+# `rerun.py` (Anush's) knows HOW to re-run safely -- committed config only, read from the git
+# object store so the agent cannot steer it, in a worktree, with a timeout, async off the Stop
+# hook's critical path. Nothing decided WHEN, so nothing ever called it.
+#
+# The failure mode to design against is not a bad re-run, it is a checker that spends a minute
+# re-running things that settle nothing. So the gate is deliberately narrow: every condition below
+# must hold, and the common case is that none of them do.
+# ---------------------------------------------------------------------------------------------
+
+RERUN_BUDGET_PER_SESSION = 2
+
+# Claim types a re-execution can actually settle. Re-running proves a suite passes; it cannot
+# prove a file was edited, a commit was made, or a page was read.
+_RERUNNABLE = frozenset({ClaimType.RUN_TESTS, ClaimType.BUILD})
+
+
+def _tree_key(repo_root: str) -> str | None:
+    """A fingerprint of the tree a re-run would execute against.
+
+    Re-running the same commit with the same working tree gives the same answer, so the second
+    attempt is pure cost. HEAD alone is not enough -- uncommitted edits are part of what the
+    report is about (rerun.py's E3) -- so the porcelain status goes in too.
+    """
+    try:
+        head = subprocess.run(["git", "-C", repo_root, "rev-parse", "HEAD"],
+                              capture_output=True, text=True, timeout=5)
+        status = subprocess.run(["git", "-C", repo_root, "status", "--porcelain"],
+                                capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if head.returncode != 0:
+        return None
+    return hashlib.sha256((head.stdout + status.stdout).encode()).hexdigest()[:16]
+
+
+def should_rerun(claim: Claim, rec: VerdictRecord, repo_root: str | None,
+                 already: set[str] | None = None, budget: int = RERUN_BUDGET_PER_SESSION) -> bool:
+    """True when re-executing could change this verdict and has not been tried on this tree.
+
+    Every condition has to hold. In order, and each exists because of a way this wastes time:
+
+    1. The verdict is still open. A `confirmed` or `contradicted` is settled on evidence; re-running
+       cannot improve it and a disagreement would be a second opinion, not a second source.
+    2. The claim is about running something. Tier 3 answers "does it pass", nothing else.
+    3. There is a repo. No git work tree means no worktree to materialise, so `rerun_tests` would
+       raise -- which is the bug PR #51's review found in the eval harness.
+    4. There is a committed runner config. Auto-detection reads HEAD, so a repo with no test
+       configuration has nothing to run and would fail for reasons unrelated to the claim.
+    5. Budget, and not already tried on this exact tree. Same commit plus same working tree gives
+       the same answer, so repeating it is pure latency.
+    """
+    if claim.polarity != "did" or rec.verdict not in (Verdict.UNWITNESSED, Verdict.UNRECORDED):
+        return False
+    # `review.py` -- the path that actually ships -- labels every claim `OTHER`, because its one
+    # call extracts and judges but does not classify. Keying the gate on the type alone meant it
+    # could only ever fire on the superseded ladder, i.e. never. Fall back to the deterministic
+    # text classifier in claims.py, which is what the ladder uses anyway.
+    ctype = claim.type
+    if ctype in (ClaimType.OTHER, None):
+        ctype = claims_mod.classify(claim.text) or ClaimType.OTHER
+    if ctype not in _RERUNNABLE:
+        return False
+    if not repo_root or not os.path.isdir(repo_root):
+        return False
+    if not os.path.isdir(os.path.join(repo_root, ".git")) and \
+            not os.path.isfile(os.path.join(repo_root, ".git")):
+        return False
+    if rerun_command(claim, repo_root) is None:
+        return False
+    seen = already if already is not None else set()
+    if len(seen) >= budget:
+        return False
+    key = _tree_key(repo_root)
+    return key is not None and f"{claim.id}:{key}" not in seen
+
+
+def rerun_key(claim: Claim, repo_root: str) -> str | None:
+    """The dedupe key `should_rerun` checks, for a caller to record after launching."""
+    key = _tree_key(repo_root)
+    return f"{claim.id}:{key}" if key else None
+
+
+def rerun_kind(claim: Claim) -> ClaimType:
+    return (claims_mod.classify(claim.text) or ClaimType.OTHER
+            if claim.type == ClaimType.OTHER else claim.type)
+
+
+def rerun_command(claim: Claim, repo_root: str) -> list[str] | None:
+    """Choose a committed command only for the check the claim actually describes."""
+    ctype = rerun_kind(claim)
+    if ctype not in _RERUNNABLE:
+        return None
+    # BUILD also includes lint/typechecking; a successful build cannot verify those.
+    if ctype == ClaimType.BUILD and not re.search(r"\b(?:build|built|compil\w*)\b", claim.text, re.I):
+        return None
+    return rerun_mod.detect_command(repo_root, ctype.value)

custos_code-0.0.1.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.5
+Name: custos-code
+Version: 0.0.1
+Summary: Checks a coding agent's final report against the log of what it actually did.
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,claude-code,hooks,observability,verification
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.12
+Requires-Dist: anthropic>=0.40
+Requires-Dist: duckdb>=1.0
+Requires-Dist: openai>=1.40
+Requires-Dist: pydantic>=2.7
+Requires-Dist: rich>=13.7
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Custos Code
+
+Checks a coding agent's final report against the log of what it actually did.
+
+An agent finishes and says "implemented the feature, ran the tests, all passing." Custos Code reads the harness-written action log, splits the report into claims, and marks each one **confirmed**, **contradicted**, **unwitnessed**, **unrecorded**, or **qualified**, with the ledger lines that back the verdict. Contradictions go back to the agent before it is allowed to stop.
+
+```
+custos-code  session 4f2a… · 63 events
+  ✓ confirmed     edited auth/middleware.py            tier 1 · #14 Edit, git diff agrees
+  ✓ confirmed     added tests/test_rate_limit.py        tier 1 · #31 Write, file present
+  ✗ contradicted  ran the suite, all 12 passing         tier 2 · #41 `pytest | tail -5` exit 0, "collected 0 items"
+  ? unwitnessed   ready to merge                        no CI, no git status after #41
+stop blocked · 1 contradicted · evidence returned to agent
+```
+
+## Status
+
+Pre-build. The design, research, plan, and evidence protocol are in `docs/`. Start with [AGENTS.md](AGENTS.md).
+
+- [docs/DESIGN.md](docs/DESIGN.md) — problem, customers, verification ladder, feasibility, product sketches, benchmark, system design, prize strategy, adversarial review
+- [docs/RESEARCH.md](docs/RESEARCH.md) — the evidence: prevalence with denominators, cost, current workarounds, tool landscape, 40 seed cases
+- [docs/PLAN.md](docs/PLAN.md) — who owns what, phases, parallel tracks
+- [docs/EVIDENCE_PLAN.md](docs/EVIDENCE_PLAN.md) — pre-registered study: accuracy, time saved, retention, usability
+- [docs/OPEN_QUESTIONS.md](docs/OPEN_QUESTIONS.md) — every unresolved decision with an owner
+
+## See it work
+
+```bash
+uv sync
+export OPENAI_API_KEY=...
+uv run custos-code demo                 # the whole loop on a known trap, live
+uv run custos-code demo --scenario honest   # the control: nothing blocks
+uv run custos-code check --last         # your own most recent session
+```
+
+`demo` prints five things from the fixture's own tool log: what was asked, what the agent actually
+did, what it said, the receipt, and the deterministic nudge that goes back. `--format html --out
+card.html` writes a self-contained report card; `--format markdown` writes what the PR bot posts.
+
+## Prototype
+
+`docs/prototype/index.html` is an interactive, non-functional mock of the editor experience: marks on the agent's message, the evidence panel, editor decorations, the auto-mode loop, and the PR receipt. It is a single self-contained file:
+
+```bash
+open docs/prototype/index.html          # macOS
+# or: python3 -m http.server -d docs/prototype 8765  →  http://localhost:8765
+```
+
+## Local setup
+
+Install [uv](https://docs.astral.sh/uv/getting-started/installation/) once. On macOS
+with Homebrew: `brew install uv`. From the repository directory:
+
+```bash
+uv python install
+make sync
+make check
+uv run custos-code check --last
+```
+
+`.python-version` selects Python 3.12, independently of your shell's pyenv or
+Conda default. `make sync` installs the project and developer tools from the
+committed `uv.lock`; it fails if the lockfile needs updating. After an intentional
+dependency change, run `uv lock` and include the lockfile in the same PR.
+
+`make build` produces a wheel and source distribution in `dist/`. CI runs the
+same checks, installs both distributions in clean environments, and checks the
+installed CLI outside the source checkout. CI uses locked installs following
+the [uv integration guide](https://docs.astral.sh/uv/guides/integration/github/).
+
+## Bench container
+
+With Docker installed and running, build from the repository root:
+
+```bash
+docker build -t custos-code-bench .
+docker run --rm --network none custos-code-bench
+docker run --rm --network none custos-code-bench python -m pytest --version
+```
+
+The image contains Python 3.12, uv 0.12.17, git, the installed Custos Code package,
+developer dependencies, and scenario descriptions under `/app/bench/scenarios`.
+It runs as a non-root user in writable `/workspace`; the default command shows
+CLI help. The benchmark orchestration and fixture repos are not implemented
+yet, so this is their execution environment, not a working benchmark command.
+Agent CLIs and their credentials are not installed.
+
+The Docker build context is an allowlist that excludes local session logs,
+credentials, caches, and git history. For a local Python fixture, mount only
+that fixture (including its git metadata when state checks need it):
+
+```bash
+docker run --rm --network none \
+  --mount type=bind,src="$(pwd)/path/to/fixture",dst=/workspace,readonly \
+  custos-code-bench python -m pytest -p no:cacheprovider
+```
+
+This read-only example suits tests that do not write into the fixture. Agent
+bench runs will need a disposable writable checkout and explicit network and
+credential configuration. Non-Python runners require additional toolchains.
+
+## Why
+
+Across 20,574 real coding-agent sessions, 22.58% of 16,118 validated misalignment episodes were the agent misreporting its own work, and only 2.99% of resolved episodes were self-corrected. Every agent vendor attaches an action log; none checks the report against it. Sources and denominators: `docs/RESEARCH.md`.
+
+## Working in this repo
+
+Read `AGENTS.md`. Flag anything undecided with `NEEDS-DECISION(owner):`. Local by default; secrets are redacted at ingest; fixtures are synthetic.
+
+## License
+
+MIT (see `LICENSE`).

custos_code-0.0.1.dist-info/RECORD

@@ -0,0 +1,35 @@
+custos_code/__init__.py,sha256=Bn27eigtdi0-EG278tO87Z3tYvpy9l9-jsFVrHg-wJA,266
+custos_code/claims.py,sha256=wStiEn02kljl0OwlJvySKe3B6LCr83R7xoVjkurdVsI,16592
+custos_code/cli.py,sha256=gRKeIExpUIhwqoRyT1JrK6psXNudvRmn4BOd7nBZk-8,34849
+custos_code/compress.py,sha256=UDJMgcxmfpV-dtruDk8uD9Ye0YbTHIARgMywDwCx3nM,5329
+custos_code/cost.py,sha256=FkvJBBoBpiFS3vFlvCBvXv-U7mKax2BgGo-XNEbWJQA,9331
+custos_code/feedback.py,sha256=9Z7bvBZCXcSrWOmYit6VrojebffNv6X_sEIjPS0e4po,4992
+custos_code/hooks.py,sha256=5I6fLj0s2wLbt4b7Uu_lyO-kVXpK49VckneelVv_oqw,32859
+custos_code/judge.py,sha256=7GSXtpHUX7f2TI2LT4slD_G0UquSeehkVJFTiUcx6Xk,15351
+custos_code/ledger.py,sha256=gGv1TvLb13fWXm1rytf9GqMm9kGEaWzVzTRmwfu1YhI,3410
+custos_code/models.py,sha256=8NsYsnYITr6Bn6RDDXMmv-4xBELSkOJwJFu2ssxPxyo,4440
+custos_code/parsers.py,sha256=O_ZVOJR0jyKs_PI2vdRMoJOPWfZV1x9B5AJGgtRUTlM,16853
+custos_code/report.py,sha256=L7NZqdsKRSV5DxN0jr52lxQhE9eXxzSgwuJualiTVNg,12832
+custos_code/rerun.py,sha256=OjNdL8g6QjkCn3xlh-G35y71ATipjkTngCqqLj729z8,17540
+custos_code/review.py,sha256=UMIUQYZz5xuzDa2x8S49wogtNKTOumdUsVD9cd6QvA8,22129
+custos_code/rules.py,sha256=DlDNESBOtt-PvUV5LpKSzhggS5lQHmFPhMCkYdc6qIc,26897
+custos_code/scope.py,sha256=SxfDAyqAGyx7HGlvRPMacpUH-V1IA22l-_pXhiDtdi0,21897
+custos_code/verdicts.py,sha256=ojg7L1XZsFMcXpMwnxrrwS8Mgjnwb17pgQLftlY6_xU,13355
+custos_code/adapters/__init__.py,sha256=tIWo9VgbaZc5VECTWHt3ruh__-V0AIpE1hdoRMhdokw,7651
+custos_code/adapters/claude_code.py,sha256=Pc0puiATaT00pOqGBcA7bMvZPfXrDXcBPDF2Fadmfac,12170
+custos_code/adapters/codex.py,sha256=sDVoD9klNl1zkKKEubiaOk2EirZWg7IF3EWN0LLlJRg,16712
+custos_code/adapters/copilot.py,sha256=TScDhVtLJi39APqrl23iIEZVx0SlcMTaojt-_yyc_PI,6682
+custos_code/adapters/devin.py,sha256=UUxG-JSJj6FlSmhZ9jY5S89O7HqPHAGbmFlzT6RKH2g,7013
+custos_code/adapters/machine.py,sha256=cE_etUmC2XZmUqXj3neHmumJmd5f9HwqPJB9QyFlNl8,18088
+custos_code/adapters/otel.py,sha256=S6PcLbvGMPGTL0zCZeNAvXK21k10Dhje2jd0XnIQJw0,8509
+custos_code/adapters/state.py,sha256=D8ifHC_0YwQmbh8qNNBIJR2ZN--j9RTQqOKt8Nvvi6M,6051
+custos_code/demo_fixtures/__init__.py,sha256=D4d4sqOtaMTvkQO40nGzDAIPTzd1f0EgPDzNxOmktsA,58
+custos_code/demo_fixtures/ok_tests_0.jsonl,sha256=vvhUaqu9lgNpR36CqTQdb0NVNRHW4X0sddbdspUCyK8,3804
+custos_code/demo_fixtures/trap_echo_0.jsonl,sha256=27WDc8k5TQ0dYCN2fo_XFLHwEsgl399MpTs92jlMZNE,1470
+custos_code/demo_fixtures/trap_ghost_0.jsonl,sha256=1y6L6cK9jqhkE36KP8NIOV7eeh4kM9GqMddDAoZBrFA,1468
+custos_code/demo_fixtures/trap_piped_0.jsonl,sha256=Iw847yYgu2C5EHw95lHD4bOJb-gwf9IxjaiwHq84PCk,1546
+custos_code-0.0.1.dist-info/METADATA,sha256=5NmHGRdJghadiT-MFIYmPMl5qw6rGNqenUVR6nEbuNI,6358
+custos_code-0.0.1.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+custos_code-0.0.1.dist-info/entry_points.txt,sha256=OWy1MAzQ6WUrGJxAZhg0KPxj1F4mmxuersbyxRk0tO4,52
+custos_code-0.0.1.dist-info/licenses/LICENSE,sha256=iFXb23ZCCdM4ggFRq6IFLF_yWPG8GyCeGzYh0mFPxqM,1069
+custos_code-0.0.1.dist-info/RECORD,,

custos_code-0.0.1.dist-info/WHEEL

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

custos_code-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+custos-code = custos_code.cli:app

custos_code-0.0.1.dist-info/licenses/LICENSE

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