verityledger 0.1.0__py3-none-any.whl

verityledger/__init__.py

@@ -0,0 +1,24 @@
+from .chain import Entry, verify_chain
+from .core import Session, Tracer
+from .exceptions import (
+    ChainIntegrityError,
+    SessionNotFoundError,
+    StorageError,
+    VerityLedgerError,
+)
+from .storage import LocalStore, Store
+
+__all__ = [
+    "Tracer",
+    "Session",
+    "Entry",
+    "verify_chain",
+    "Store",
+    "LocalStore",
+    "VerityLedgerError",
+    "StorageError",
+    "ChainIntegrityError",
+    "SessionNotFoundError",
+]
+
+__version__ = "0.1.0"

verityledger/chain.py

@@ -0,0 +1,107 @@
+"""
+Hash-chained, tamper-evident log entries.
+
+Each entry includes a hash of the previous entry, forming a chain.
+Any modification to a past entry breaks the chain for everything after it,
+making tampering detectable without needing a blockchain or external service.
+
+This module has zero dependencies on storage or the public API — it is the
+single source of truth for what an "entry" is and how the chain is verified.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+import uuid
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+GENESIS_HASH = "0" * 64
+
+
+def _canonical_json(data: dict[str, Any]) -> str:
+    """Serialize a dict deterministically so hashes are reproducible."""
+    return json.dumps(data, sort_keys=True, separators=(",", ":"), default=str)
+
+
+@dataclass(frozen=True)
+class Entry:
+    """A single chained log entry."""
+
+    id: str
+    session_id: str
+    timestamp: float
+    event_type: str
+    data: dict[str, Any]
+    previous_hash: str
+    hash: str = field(default="")
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, raw: dict[str, Any]) -> Entry:
+        return cls(**raw)
+
+    @property
+    def content_hash(self) -> str:
+        """Hash of this entry's content, excluding the stored `hash` field."""
+        content = {k: v for k, v in self.to_dict().items() if k != "hash"}
+        return hashlib.sha256(_canonical_json(content).encode("utf-8")).hexdigest()
+
+
+def make_entry(
+    session_id: str,
+    event_type: str,
+    data: dict[str, Any],
+    previous_hash: str,
+) -> Entry:
+    """
+    Build a single chained log entry, with its hash computed and set.
+
+    Args:
+        session_id: identifier for the agent run / conversation this belongs to.
+        event_type: e.g. "tool_call", "model_call", "decision".
+        data: arbitrary JSON-serializable payload for this event.
+        previous_hash: hash of the prior entry in this session's chain
+                        (use GENESIS_HASH for the first entry).
+
+    Returns:
+        A completed, hashed Entry.
+    """
+    entry = Entry(
+        id=str(uuid.uuid4()),
+        session_id=session_id,
+        timestamp=time.time(),
+        event_type=event_type,
+        data=data,
+        previous_hash=previous_hash,
+        hash="",
+    )
+    return Entry(**{**entry.to_dict(), "hash": entry.content_hash})
+
+
+def verify_chain(entries: list[Entry]) -> tuple[bool, int | None]:
+    """
+    Verify a list of entries forms an unbroken, untampered hash chain.
+
+    The list is assumed to be in chronological order for a single session.
+    An empty list is considered valid (vacuously).
+
+    Returns:
+        (is_valid, index_of_first_break_or_none)
+    """
+    expected_previous = GENESIS_HASH
+
+    for i, entry in enumerate(entries):
+        if entry.previous_hash != expected_previous:
+            return False, i
+
+        if entry.content_hash != entry.hash:
+            return False, i
+
+        expected_previous = entry.hash
+
+    return True, None

verityledger/cli/__init__.py

@@ -0,0 +1,3 @@
+from .__main__ import main
+
+__all__ = ["main"]

verityledger/cli/__main__.py

@@ -0,0 +1,134 @@
+"""
+VerityLedger CLI.
+
+Lets you inspect, verify, and export logs from the terminal without
+writing any Python. Built entirely on top of the public `verityledger`
+API (Tracer/LocalStore) - the CLI has no logic of its own beyond
+argument parsing and formatting.
+
+Usage:
+    verityledger sessions [--log PATH]
+    verityledger show SESSION_ID [--log PATH]
+    verityledger verify SESSION_ID [--log PATH]
+    verityledger export SESSION_ID OUT_PATH [--log PATH]
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from datetime import datetime, timezone
+
+from ..core import Tracer
+from ..exceptions import ChainIntegrityError, SessionNotFoundError, VerityLedgerError
+
+DEFAULT_LOG_PATH = "./verityledger_log.jsonl"
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="verityledger",
+        description="Inspect, verify, and export VerityLedger agent logs.",
+    )
+    parser.add_argument(
+        "--log",
+        default=DEFAULT_LOG_PATH,
+        help=f"Path to the log file (default: {DEFAULT_LOG_PATH})",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("sessions", help="List all session ids in the log.")
+
+    show = subparsers.add_parser("show", help="Print all entries for a session.")
+    show.add_argument("session_id")
+
+    verify = subparsers.add_parser("verify", help="Check a session's hash chain for tampering.")
+    verify.add_argument("session_id")
+
+    export = subparsers.add_parser("export", help="Export a session as a JSON audit report.")
+    export.add_argument("session_id")
+    export.add_argument("out_path")
+
+    return parser
+
+
+def _format_timestamp(ts: float) -> str:
+    return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+
+
+def cmd_sessions(tracer: Tracer) -> int:
+    sessions = tracer.store.all_sessions()
+    if not sessions:
+        print("No sessions found.")
+        return 0
+    for sid in sessions:
+        count = len(tracer.store.get_session(sid))
+        print(f"{sid}  ({count} entries)")
+    return 0
+
+
+def cmd_show(tracer: Tracer, session_id: str) -> int:
+    entries = tracer.store.get_session(session_id)
+    if not entries:
+        print(f"No entries found for session '{session_id}'.", file=sys.stderr)
+        return 1
+    for entry in entries:
+        print(f"[{_format_timestamp(entry.timestamp)}] {entry.event_type}")
+        for key, value in entry.data.items():
+            print(f"    {key}: {value}")
+        print(f"    hash: {entry.hash[:12]}...")
+    return 0
+
+
+def cmd_verify(tracer: Tracer, session_id: str) -> int:
+    try:
+        tracer.assert_valid(session_id)
+    except SessionNotFoundError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+    except ChainIntegrityError as exc:
+        print(f"TAMPERING DETECTED: {exc}", file=sys.stderr)
+        return 1
+
+    entry_count = len(tracer.store.get_session(session_id))
+    print(f"Chain valid: {entry_count} entries, no tampering detected.")
+    return 0
+
+
+def cmd_export(tracer: Tracer, session_id: str, out_path: str) -> int:
+    try:
+        report = tracer.export_report(session_id, out_path)
+    except SessionNotFoundError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+    status = "valid" if report["chain_valid"] else "TAMPERED"
+    print(f"Exported {report['entry_count']} entries to {out_path} (chain: {status}).")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    tracer = Tracer(log_path=args.log)
+
+    try:
+        if args.command == "sessions":
+            return cmd_sessions(tracer)
+        if args.command == "show":
+            return cmd_show(tracer, args.session_id)
+        if args.command == "verify":
+            return cmd_verify(tracer, args.session_id)
+        if args.command == "export":
+            return cmd_export(tracer, args.session_id, args.out_path)
+    except VerityLedgerError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

verityledger/core.py

@@ -0,0 +1,204 @@
+"""
+VerityLedger — public API.
+
+Quickstart:
+
+    from verityledger import Tracer
+
+    tracer = Tracer()  # writes to ./verityledger_log.jsonl by default
+
+    with tracer.session(agent="weather-bot") as session:
+
+        @session.trace_tool
+        def get_weather(city: str) -> dict:
+            return {"city": city, "forecast": "sunny"}
+
+        result = get_weather("Mumbai")
+
+        session.log_decision(
+            "no umbrella needed",
+            reasoning="forecast is sunny",
+        )
+
+    tracer.export_report(session.id, "report.json")
+"""
+
+from __future__ import annotations
+
+import functools
+import json
+import logging
+import time
+import uuid
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from typing import Any, TypeVar
+
+from .chain import Entry, make_entry, verify_chain
+from .exceptions import ChainIntegrityError, SessionNotFoundError
+from .storage import LocalStore, Store
+
+logger = logging.getLogger("verityledger")
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+class Session:
+    """A single traced run (e.g. one agent conversation or job)."""
+
+    def __init__(self, tracer: Tracer, session_id: str, metadata: dict[str, Any] | None = None):
+        self._tracer = tracer
+        self.id = session_id
+        if metadata:
+            self.log_event("session_start", metadata)
+
+    def log_event(self, event_type: str, data: dict[str, Any]) -> Entry:
+        """Log a raw event to this session's chain. Returns the stored entry."""
+        store = self._tracer.store
+        previous_hash = store.latest_hash(self.id)
+        entry = make_entry(self.id, event_type, data, previous_hash)
+        store.append(entry)
+        logger.debug("logged %s entry for session %s", event_type, self.id)
+        return entry
+
+    def log_decision(self, decision: str, reasoning: str | None = None, **extra: Any) -> Entry:
+        """Record a decision an agent made, with optional reasoning/context."""
+        data: dict[str, Any] = {"decision": decision}
+        if reasoning is not None:
+            data["reasoning"] = reasoning
+        data.update(extra)
+        return self.log_event("decision", data)
+
+    def log_model_call(
+        self, prompt: Any, response: Any, model: str | None = None, **extra: Any
+    ) -> Entry:
+        """Record an LLM call's input and output."""
+        data: dict[str, Any] = {"prompt": prompt, "response": response}
+        if model:
+            data["model"] = model
+        data.update(extra)
+        return self.log_event("model_call", data)
+
+    def trace_tool(self, func: F) -> F:
+        """
+        Decorator: wraps a tool function so each call (args, result, timing,
+        and any exception) is recorded as a tool_call entry.
+        """
+
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            started = time.monotonic()
+            try:
+                result = func(*args, **kwargs)
+                self.log_event(
+                    "tool_call",
+                    {
+                        "tool": func.__name__,
+                        "args": _safe(args),
+                        "kwargs": _safe(kwargs),
+                        "result": _safe(result),
+                        "duration_seconds": time.monotonic() - started,
+                        "status": "success",
+                    },
+                )
+                return result
+            except Exception as exc:
+                self.log_event(
+                    "tool_call",
+                    {
+                        "tool": func.__name__,
+                        "args": _safe(args),
+                        "kwargs": _safe(kwargs),
+                        "error": str(exc),
+                        "error_type": type(exc).__name__,
+                        "duration_seconds": time.monotonic() - started,
+                        "status": "error",
+                    },
+                )
+                raise
+
+        return wrapper  # type: ignore[return-value]
+
+
+class Tracer:
+    """Top-level entry point. Holds the storage backend and creates sessions."""
+
+    def __init__(self, store: Store | None = None, log_path: str = "./verityledger_log.jsonl"):
+        self.store: Store = store or LocalStore(log_path)
+
+    @contextmanager
+    def session(self, session_id: str | None = None, **metadata: Any) -> Iterator[Session]:
+        """
+        Context manager that yields a Session with a unique id (auto-generated
+        if not provided). Any metadata kwargs are recorded as a session_start event.
+        """
+        sid = session_id or str(uuid.uuid4())
+        session = Session(self, sid, metadata=metadata or None)
+        try:
+            yield session
+        finally:
+            session.log_event("session_end", {})
+
+    def verify(self, session_id: str) -> tuple[bool, int | None]:
+        """Verify the hash chain for a session is intact (no tampering)."""
+        entries = self.store.get_session(session_id)
+        return verify_chain(entries)
+
+    def assert_valid(self, session_id: str) -> None:
+        """
+        Like verify(), but raises instead of returning a tuple.
+
+        Raises:
+            SessionNotFoundError: if the session has no entries.
+            ChainIntegrityError: if the chain is broken or tampered with.
+        """
+        entries = self.store.get_session(session_id)
+        if not entries:
+            raise SessionNotFoundError(session_id)
+        valid, break_index = verify_chain(entries)
+        if not valid:
+            assert break_index is not None
+            raise ChainIntegrityError(session_id, break_index)
+
+    def export_report(self, session_id: str, path: str) -> dict[str, Any]:
+        """
+        Export a JSON audit report for a session: full entry list plus
+        a verification result. Returns the report dict and writes it to `path`.
+
+        Raises:
+            SessionNotFoundError: if the session has no entries.
+        """
+        entries = self.store.get_session(session_id)
+        if not entries:
+            raise SessionNotFoundError(session_id)
+
+        valid, break_index = verify_chain(entries)
+        report = {
+            "session_id": session_id,
+            "entry_count": len(entries),
+            "chain_valid": valid,
+            "chain_break_index": break_index,
+            "entries": [e.to_dict() for e in entries],
+        }
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(report, f, indent=2, default=str)
+        return report
+
+
+def _safe(value: Any) -> Any:
+    """
+    Best-effort JSON-safe conversion for log payloads.
+
+    Recurses into lists/tuples/dicts so that a single non-serializable
+    object (e.g. a custom class instance) doesn't make the whole
+    container fall back to a single opaque repr string.
+    """
+    if isinstance(value, (list, tuple)):
+        return [_safe(v) for v in value]
+    if isinstance(value, dict):
+        return {str(k): _safe(v) for k, v in value.items()}
+    try:
+        json.dumps(value)
+        return value
+    except TypeError:
+        return repr(value)

verityledger/exceptions.py

@@ -0,0 +1,34 @@
+"""
+VerityLedger exception hierarchy.
+
+All exceptions raised by this library inherit from VerityLedgerError, so
+callers can catch broadly (`except VerityLedgerError`) or narrowly.
+"""
+
+
+class VerityLedgerError(Exception):
+    """Base class for all VerityLedger exceptions."""
+
+
+class StorageError(VerityLedgerError):
+    """Raised when a storage backend fails to read or write entries."""
+
+
+class ChainIntegrityError(VerityLedgerError):
+    """Raised when a hash chain is found to be broken or tampered with."""
+
+    def __init__(self, session_id: str, break_index: int):
+        self.session_id = session_id
+        self.break_index = break_index
+        super().__init__(
+            f"Hash chain for session '{session_id}' is broken at entry "
+            f"index {break_index}."
+        )
+
+
+class SessionNotFoundError(VerityLedgerError):
+    """Raised when a requested session has no entries in storage."""
+
+    def __init__(self, session_id: str):
+        self.session_id = session_id
+        super().__init__(f"No entries found for session '{session_id}'.")

verityledger/storage/__init__.py

@@ -0,0 +1,4 @@
+from .base import Store
+from .local import LocalStore
+
+__all__ = ["Store", "LocalStore"]

verityledger/storage/base.py

@@ -0,0 +1,45 @@
+"""
+Storage interface.
+
+Any backend (local file, SQLite, Postgres, hosted API) implements this
+protocol. The rest of the library only depends on this interface, never
+on a concrete backend - that's what lets a hosted "VerityLedger Cloud" store
+be dropped in later with zero changes to chain.py or core.py.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from ..chain import GENESIS_HASH, Entry
+
+
+class Store(ABC):
+    """Abstract base class for VerityLedger storage backends."""
+
+    @abstractmethod
+    def append(self, entry: Entry) -> None:
+        """Persist a single entry. Must preserve insertion order."""
+
+    @abstractmethod
+    def get_session(self, session_id: str) -> list[Entry]:
+        """Return all entries for a session, in the order they were written."""
+
+    @abstractmethod
+    def all_sessions(self) -> list[str]:
+        """Return distinct session ids, in first-seen order."""
+
+    @abstractmethod
+    def all_entries(self) -> list[Entry]:
+        """Return every entry across all sessions, in insertion order."""
+
+    def latest_hash(self, session_id: str) -> str:
+        """
+        Return the hash of the most recent entry for a session, or
+        GENESIS_HASH if the session has no entries yet.
+
+        Backends may override this with a more efficient implementation
+        (e.g. an indexed query) - the default just scans get_session().
+        """
+        entries = self.get_session(session_id)
+        return entries[-1].hash if entries else GENESIS_HASH

verityledger/storage/local.py

@@ -0,0 +1,73 @@
+"""
+Local, file-based storage backend.
+
+Free-tier default: an append-only JSONL file. No database required.
+Each line is one Entry, serialized as JSON. Append is O(1); reads scan
+the file, which is fine for the local/single-developer use case this
+backend targets. A SQLite or Postgres backend (for the hosted product)
+can implement the same Store interface with indexed lookups.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Iterator
+from pathlib import Path
+
+from ..chain import Entry
+from ..exceptions import StorageError
+from .base import Store
+
+
+class LocalStore(Store):
+    """Append-only JSONL store, one file per project/log."""
+
+    def __init__(self, path: str | os.PathLike[str] = "./verityledger_log.jsonl"):
+        self.path = Path(path)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        if not self.path.exists():
+            self.path.touch()
+
+    def append(self, entry: Entry) -> None:
+        try:
+            serialized = json.dumps(entry.to_dict(), default=str)
+        except TypeError as exc:
+            raise StorageError(f"Entry is not JSON-serializable: {exc}") from exc
+
+        try:
+            with open(self.path, "a", encoding="utf-8") as f:
+                f.write(serialized + "\n")
+        except OSError as exc:
+            raise StorageError(f"Failed to write to {self.path}: {exc}") from exc
+
+    def get_session(self, session_id: str) -> list[Entry]:
+        return [e for e in self._read_all() if e.session_id == session_id]
+
+    def all_sessions(self) -> list[str]:
+        seen: list[str] = []
+        for entry in self._read_all():
+            if entry.session_id not in seen:
+                seen.append(entry.session_id)
+        return seen
+
+    def all_entries(self) -> list[Entry]:
+        return list(self._read_all())
+
+    def _read_all(self) -> Iterator[Entry]:
+        if not self.path.exists():
+            return
+        try:
+            with open(self.path, encoding="utf-8") as f:
+                for line_number, line in enumerate(f, start=1):
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        yield Entry.from_dict(json.loads(line))
+                    except (json.JSONDecodeError, TypeError) as exc:
+                        raise StorageError(
+                            f"Corrupt entry at {self.path}:{line_number}: {exc}"
+                        ) from exc
+        except OSError as exc:
+            raise StorageError(f"Failed to read {self.path}: {exc}") from exc

verityledger-0.1.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: verityledger
+Version: 0.1.0
+Summary: Tamper-evident decision and tool-call logging for AI agents.
+Author: VerityLedger
+License: MIT
+Project-URL: Homepage, https://github.com/verityledger/verityledger
+Project-URL: Issues, https://github.com/verityledger/verityledger/issues
+Keywords: ai,agents,audit,logging,llm,observability
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file
+
+# VerityLedger
+
+**Know exactly what your AI agent did, and prove nothing was changed after the fact.**
+
+VerityLedger is a small Python library that wraps your agent's tool calls and
+decisions in a tamper-evident, hash-chained log. When something goes wrong —
+a bad refund, a broken deploy, a strange customer reply — you can pull up the
+exact sequence of tool calls, model inputs/outputs, and reasoning that led
+there, and prove the record hasn't been altered.
+
+No database. No external service. No blockchain. Just an append-only file
+and SHA-256.
+
+```python
+from verityledger import Tracer
+
+tracer = Tracer()  # writes to ./verityledger_log.jsonl
+
+with tracer.session(agent="support-bot", user="user_123") as session:
+
+    @session.trace_tool
+    def issue_refund(order_id: str, amount: float) -> str:
+        return f"refunded {amount} for {order_id}"
+
+    issue_refund("ORD-4471", 42.00)
+
+    session.log_decision(
+        "approved refund",
+        reasoning="customer reported damaged item, photo provided, within policy",
+    )
+```
+
+Every call to `issue_refund`, every `log_decision`, and any model calls you
+log are written as chained entries — each one includes a hash of the
+previous entry. If anyone edits a past entry, the chain breaks at exactly
+that point.
+
+## Why this exists
+
+Agents are making real decisions — refunds, emails, code pushes, customer
+replies — and most teams have no record of *why* beyond scattered print
+statements and provider dashboards. When a regulator, a customer, or your
+own team asks "why did the bot do that?", you want an answer that's both
+complete and verifiable.
+
+## Install
+
+```bash
+pip install verityledger
+```
+
+## Verify the chain
+
+```python
+valid, break_index = tracer.verify(session.id)
+# valid == True, break_index == None  (until someone tampers with the log)
+
+# Or raise on problems:
+tracer.assert_valid(session.id)
+# raises ChainIntegrityError or SessionNotFoundError
+```
+
+## Export an audit report
+
+```python
+tracer.export_report(session.id, "incident_report.json")
+```
+
+Produces a single JSON file with every entry for that session, plus the
+verification result — ready to attach to an incident review or compliance
+request.
+
+## CLI
+
+Installing the package also installs a `verityledger` command:
+
+```bash
+verityledger sessions                          # list session ids in the log
+verityledger show <session_id>                 # print all entries for a session
+verityledger verify <session_id>               # check the hash chain for tampering
+verityledger export <session_id> report.json   # write a JSON audit report
+```
+
+All commands accept `--log PATH` to point at a specific log file
+(default: `./verityledger_log.jsonl`).
+
+## Architecture
+
+The library is layered so each piece can be tested and replaced independently:
+
+- **`chain.py`** — the cryptographic primitive. Defines `Entry`, hashing,
+  and `verify_chain`. No I/O, no dependencies.
+- **`storage/`** — the `Store` interface plus `LocalStore` (append-only
+  JSONL). A hosted backend (SQLite/Postgres/API) implements the same
+  interface and drops in without touching anything above it.
+- **`core.py`** — the public API: `Tracer` and `Session`.
+- **`cli/`** — the `verityledger` terminal command. Built entirely on top of
+  the public API above; no logic of its own beyond argument parsing
+  and output formatting.
+- **`exceptions.py`** — shared error types (`StorageError`,
+  `ChainIntegrityError`, `SessionNotFoundError`).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+ruff check .          # lint
+mypy src/verityledger    # strict type check
+pytest                # tests + coverage
+```
+
+## Status
+
+Early release. The local file-based logger (above) is free and open source
+(MIT) — your data never leaves your machine. A hosted dashboard for
+searching across sessions, team access, and longer retention is in
+development.
+
+## Roadmap
+
+- [x] Hash-chained local logging (Python)
+- [x] Tool-call decorator, decision logging, model-call logging
+- [x] Tamper detection / chain verification
+- [x] Audit report export
+- [x] Full test suite, type checking, CI
+- [x] CLI (`verityledger sessions/show/verify/export`)
+- [ ] JavaScript/TypeScript SDK
+- [ ] Hosted dashboard (search, team accounts, retention policies)
+- [ ] LangChain / OpenAI / Anthropic tool-use integrations
+- [ ] Remote ingestion endpoint (send logs to VerityLedger Cloud)
+
+## License
+
+MIT

verityledger-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+verityledger/__init__.py,sha256=KQuI912Dk5IhkwNDdIlzdF3GBgMlzwQDjtCK3UX0HZg,463
+verityledger/chain.py,sha256=wyWCBmT6LIE1bOdrBThVN5kqRTnB-1_-goxzjM8gRYY,3050
+verityledger/core.py,sha256=w3BB2XPNbKVGIpOUn8puwNXOfvJzE1S--MGji7Zmu4k,7057
+verityledger/exceptions.py,sha256=DoQAjBi4tqKaMTAiw4JmmCGN-XDVdqEC_M90RhZXWNY,1064
+verityledger/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+verityledger/cli/__init__.py,sha256=9jRVm2gCiDxGHfum8z9JBVNCkzjdCHJ0OApdD8C7SiM,47
+verityledger/cli/__main__.py,sha256=OWS5h2rTpemLF2qun-zo9wgxPxeoZXyge5mv3OZ_Pnw,4160
+verityledger/storage/__init__.py,sha256=IlbXaXOsLtaHpj5v0IcweG9zVrjGRsezk-DyUTAl6to,89
+verityledger/storage/base.py,sha256=aNYv1PU56AwRZANfDx8ZbMx51SrXGYWY1AnKvsUA4Ds,1518
+verityledger/storage/local.py,sha256=OlYdTfBtqlacQqC_jTe8r492qZAsZVWWyWMvOLKvXts,2596
+verityledger-0.1.0.dist-info/licenses/LICENSE,sha256=tiNRXiYK2XsJ05BBIbDCBgsEdlgv-fl1a4A75WNDU0A,1066
+verityledger-0.1.0.dist-info/METADATA,sha256=KdN8jaOT00pu6cIIEJV2h9PDupwF9qG2sioYkhvmrmo,5444
+verityledger-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+verityledger-0.1.0.dist-info/entry_points.txt,sha256=nI_PhtYtmXKQMHw_ysBwTWnE8RfNbS2uOzbYOPCP8WQ,55
+verityledger-0.1.0.dist-info/top_level.txt,sha256=eU62LohLIZrqD0Wc52-2rIWYzlJbNZ10pGKvubfgocg,13
+verityledger-0.1.0.dist-info/RECORD,,

verityledger-0.1.0.dist-info/WHEEL

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

verityledger-0.1.0.dist-info/entry_points.txt

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

verityledger-0.1.0.dist-info/licenses/LICENSE

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

verityledger-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+verityledger