alethech 0.1.0__tar.gz

alethech-0.1.0/LICENSE

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

alethech-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: alethech
+Version: 0.1.0
+Summary: Verifiable agent continuity protocol — local-first, zero-LLM, zero-blockchain
+Author: AliceLabs
+License: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: cryptography>=42.0
+Requires-Dist: click>=8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file

alethech-0.1.0/README.md

@@ -0,0 +1,98 @@
+# alethech
+
+> Verifiable agent continuity protocol — local-first, zero-LLM, zero-blockchain.
+> The art of un-concealing transmission integrity.
+
+From Greek **ἀλήθεια** (aletheia, "truth as un-concealment") + **τέχνη** (techne, "art, craft").
+The art of revealing that a memory was not modified after being signed.
+
+This is the reference implementation of the protocol specified in `docs/implementacion-nucleo-minimo.md` (rev 2).
+
+## the property
+
+> **This memory set forms part of a cryptographically verifiable history associated with a determined identity, whose commits can be independently verified with respect to their integrity, cryptographic authorship, and provenance relations.**
+>
+> **When a reference checkpoint exists, it can additionally be verified that the presented history continues from that checkpoint.**
+
+The protocol does NOT prove that the agent's claims are true — only that they were signed by the identity that claims them. The truth being un-concealed is the truth about transmission integrity, not about content.
+
+## status
+
+Implementation of rev 2 spec. Six commands. No LLM, no MCP, no MarketNow, no UTA, no network, no P2P, no cloud, no consensus, no trust providers, no marketplace, no skill verification, no multi-agent consensus.
+
+## install
+
+```bash
+pip install alethech
+```
+
+For development:
+
+```bash
+git clone https://github.com/eddyflores100-lang/alethech.git
+cd alethech
+git checkout protocol-rev2
+pip install -e .
+```
+
+## usage
+
+```bash
+alethech init                              # generate identity + genesis commit
+alethech commit --content <json-file>      # create signed MemoryCommit
+alethech evidence --tool <name>            # create signed EvidenceCommit
+  --input <file> --output <file>
+alethech verify                            # verify the whole store, offline
+alethech export --output <dir>             # portable package
+alethech import --input <dir>              # import external memory
+```
+
+## what it does NOT do
+
+- It does NOT prove that the agent's claims are true. Only that they were signed by the identity that claims them.
+- It does NOT detect rollback without an external checkpoint.
+- It does NOT encrypt content at rest.
+- It does NOT delegate permissions between agents.
+- It does NOT call any LLM.
+
+## what the name means
+
+**alethech** comes from:
+
+- **aletheia (ἀλήθεια)** — Greek for "truth", more precisely "un-concealment" (Heidegger's reading: truth as the act of revealing what was hidden)
+- **techne (τέχνη)** — Greek for "art, craft, technique"
+
+So alethech = "the art of un-concealing". The protocol un-conceals:
+- whether a memory was modified after being signed
+- who signed it
+- when it was signed
+- what its provenance is
+- whether the chain of custody is intact
+
+It does NOT un-conceal whether the content is true — that's the agent's responsibility, not the protocol's.
+
+## tests
+
+```bash
+python -m pytest tests/
+```
+
+34 tests covering:
+- crypto primitives (Ed25519, SHA-256, base64url, base32)
+- JCS canonicalization (RFC 8785)
+- agent_id derivation (cryptographic binding to public_key)
+- MemoryCommit signing, tamper detection, wrong-key rejection
+- EvidenceCommit signing
+- all 6 CLI commands
+- checkpoint emission + rollback detection
+- identity_mismatch detection
+- export/import roundtrip preservation
+- tampered manifest rejection
+
+## license
+
+MIT.
+
+## related repositories
+
+- The companion project `memex` (Python/ChromaDB memory system) is a separate layer that handles retrieval, MCP, and graph memory. `alethech` is the cryptographic protocol layer that lives on top of `memex` to make its memory verifiable. The two will eventually converge via a write-hook integration.

alethech-0.1.0/alethech/__init__.py

@@ -0,0 +1,6 @@
+"""alethech — verifiable agent continuity protocol.
+
+Reference implementation of the protocol specified in rev 2.
+Local-first, zero-LLM, zero-blockchain.
+"""
+__version__ = "0.1.0"

alethech-0.1.0/alethech/canonical.py

@@ -0,0 +1,106 @@
+"""JCS (JSON Canonicalization Scheme) — RFC 8785.
+
+Serializes JSON to a canonical byte string suitable for hashing and signing.
+
+Implementation notes:
+- Object keys sorted by UTF-16 code unit (RFC 8785 §3.2.3).
+- Strings escaped per RFC 8259 (no escaped non-ASCII — UTF-8 direct).
+- Numbers: integer if no fractional/exponent, else minimal float repr.
+- No whitespace, no trailing newline.
+"""
+from __future__ import annotations
+
+import math
+from typing import Any
+
+# Characters that MUST be escaped in JCS (RFC 8259 §7)
+_ESCAPE_MAP = {
+    '"': '\\"',
+    "\\": "\\\\",
+    "\b": "\\b",
+    "\f": "\\f",
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+}
+
+
+def _escape_string(s: str) -> str:
+    """Escape a string per RFC 8259. Non-ASCII chars are emitted as UTF-8."""
+    out = ['"']
+    for ch in s:
+        if ch in _ESCAPE_MAP:
+            out.append(_ESCAPE_MAP[ch])
+        elif ord(ch) < 0x20:
+            out.append("\\u%04x" % ord(ch))
+        else:
+            out.append(ch)
+    out.append('"')
+    return "".join(out)
+
+
+def _serialize_number(n: float | int) -> str:
+    """Serialize a number per RFC 8785 §3.2.2.3."""
+    if isinstance(n, bool):
+        # bool is a subclass of int — handle before number conversion
+        raise TypeError("booleans are not valid JCS values at top level")
+
+    if isinstance(n, int):
+        return str(n)
+
+    # float
+    if n != n:  # NaN
+        raise ValueError("NaN not representable in JCS")
+    if n == math.inf:
+        raise ValueError("Infinity not representable in JCS")
+    if n == -math.inf:
+        raise ValueError("-Infinity not representable in JCS")
+
+    if n == 0.0:
+        # Preserve sign of zero per RFC 8785
+        return "-0" if math.copysign(1.0, n) < 0 else "0"
+
+    # Integer-valued float (e.g. 3.0)
+    if n == int(n) and abs(n) < 1e21:
+        return str(int(n))
+
+    # Use repr for shortest round-trippable representation, then strip
+    # any trailing exponent that Python adds unnecessarily.
+    s = repr(n)
+    # Python repr is fine for our purposes — it produces minimal round-trip
+    return s
+
+
+def _serialize_value(v: Any) -> str:
+    if v is None:
+        return "null"
+    if v is True:
+        return "true"
+    if v is False:
+        return "false"
+    if isinstance(v, (int, float)):
+        return _serialize_number(v)
+    if isinstance(v, str):
+        return _escape_string(v)
+    if isinstance(v, list):
+        return "[" + ",".join(_serialize_value(x) for x in v) + "]"
+    if isinstance(v, dict):
+        # Sort keys by UTF-16 code unit (RFC 8785 §3.2.3)
+        items = sorted(v.items(), key=lambda kv: kv[0].encode("utf-16-be"))
+        parts = []
+        for k, val in items:
+            if not isinstance(k, str):
+                raise TypeError(f"non-string object key: {k!r}")
+            parts.append(_escape_string(k) + ":" + _serialize_value(val))
+        return "{" + ",".join(parts) + "}"
+    raise TypeError(f"unserializable type: {type(v).__name__}")
+
+
+def canonical_json(value: Any) -> str:
+    """Return the JCS canonical string for the value."""
+    return _serialize_value(value)
+
+
+def canonical_json_bytes(value: Any) -> bytes:
+    """Return the JCS canonical bytes for the value (UTF-8 encoded)."""
+    return canonical_json(value).encode("utf-8")