gdk9-cli 0.3.0__py3-none-any.whl

gdk9/crdt.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, Tuple
+
+
+@dataclass(frozen=True)
+class LwwEntry:
+  value: Any
+  timestamp: float
+  actor: str
+
+
+def coerce_entry(raw: Any, default_actor: str = "legacy", default_ts: float = 0.0) -> LwwEntry:
+  if isinstance(raw, dict):
+    value = raw.get("value", raw)
+    try:
+      ts = float(raw.get("timestamp", default_ts))
+    except (TypeError, ValueError):
+      ts = float(default_ts)
+    actor_raw = raw.get("actor", default_actor)
+    actor = default_actor if actor_raw in {None, ""} else str(actor_raw)
+    return LwwEntry(value, ts, actor)
+  return LwwEntry(raw, float(default_ts), default_actor)
+
+
+def lww_merge(a: LwwEntry, b: LwwEntry) -> LwwEntry:
+  if b.timestamp > a.timestamp:
+    return b
+  if b.timestamp < a.timestamp:
+    return a
+  return b if b.actor >= a.actor else a
+
+
+def stamp(value: Any, actor: str | None = None, ts: float | None = None) -> Dict[str, Any]:
+  return {
+    "value": value,
+    "timestamp": float(time.time() if ts is None else ts),
+    "actor": actor or "anonymous",
+  }
+
+
+def merge_maps(
+  left: Dict[str, Any],
+  right: Dict[str, Any],
+  default_actor: str = "legacy",
+  default_ts: float = 0.0,
+) -> Tuple[Dict[str, Any], Dict[str, int], Dict[str, str]]:
+  """Merge two LWW maps.
+
+  The returned tuple contains the merged map, update statistics, and the winner side for
+  each key ("left" or "right"). When inputs omit CRDT metadata, ``default_actor`` and
+  ``default_ts`` supply deterministic fallbacks so downstream consumers never see missing
+  fields.
+  """
+  merged: Dict[str, Any] = {}
+  stats = {"added": 0, "updated": 0, "unchanged": 0}
+  winners: Dict[str, str] = {}
+  keys = set(left.keys()) | set(right.keys())
+  for key in keys:
+    has_left = key in left
+    has_right = key in right
+    if has_left and not has_right:
+      lentry = coerce_entry(left[key], default_actor, default_ts)
+      merged[key] = {"value": lentry.value, "timestamp": lentry.timestamp, "actor": lentry.actor}
+      winners[key] = "left"
+      stats["unchanged"] += 1
+      continue
+    if has_right and not has_left:
+      rentry = coerce_entry(right[key], default_actor, default_ts)
+      merged[key] = {"value": rentry.value, "timestamp": rentry.timestamp, "actor": rentry.actor}
+      winners[key] = "right"
+      stats["added"] += 1
+      continue
+
+    lentry = coerce_entry(left.get(key), default_actor, default_ts)
+    rentry = coerce_entry(right.get(key), default_actor, default_ts)
+    winner = lww_merge(lentry, rentry)
+    merged[key] = {"value": winner.value, "timestamp": winner.timestamp, "actor": winner.actor}
+    winners[key] = "left" if winner is lentry else "right"
+    if winner is lentry:
+      stats["unchanged"] += 1
+    elif lentry.value != rentry.value or lentry.timestamp != rentry.timestamp or lentry.actor != rentry.actor:
+      stats["updated"] += 1
+    else:
+      stats["unchanged"] += 1
+  return merged, stats, winners

gdk9/crypto.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+"""
+Experimental energy-driven cipher (EDPC-9).
+
+WARNING: This is not cryptographically secure. It is a reversible
+energy-guided polyalphabetic transform intended for creative/symbolic
+applications, not data security. Do not use for protecting secrets.
+"""
+
+from typing import List
+import base64
+import os
+from .errors import InputError
+
+from .principles import Principle
+from .energy import char_energy
+
+
+def _keystream(principle: Principle, key: str, length: int) -> List[int]:
+  if not key:
+    raise ValueError("Key must be non-empty")
+  ks = [char_energy(ch, principle) or 1 for ch in key]
+  # normalize to 1..9, avoid zeros
+  out: List[int] = []
+  i = 0
+  while len(out) < length:
+    out.append(ks[i % len(ks)] or 1)
+    i += 1
+  return out
+
+
+def _rotate_letter(ch: str, k: int) -> str:
+  if not ch.isalpha():
+    return ch
+  base = ord('A') if ch.isupper() else ord('a')
+  off = (ord(ch) - base + k) % 26
+  return chr(base + off)
+
+
+def _rotate_digit(ch: str, k: int) -> str:
+  if not ch.isdigit():
+    return ch
+  base = ord('0')
+  off = (ord(ch) - base + (k % 10)) % 10
+  return chr(base + off)
+
+
+def _rotate_symbol(ch: str, k: int, principle: Principle) -> str:
+  # Build a stable ordered list of known symbols; fallback to identity
+  symbols = sorted(set(principle.symbol_energy.keys()))
+  if ch not in symbols:
+    return ch
+  idx = symbols.index(ch)
+  return symbols[(idx + k) % len(symbols)]
+
+
+def encrypt(text: str, key: str, principle: Principle) -> str:
+  ks = _keystream(principle, key, len(text))
+  out = []
+  for i, ch in enumerate(text):
+    k = ks[i]
+    if ch.isalpha():
+      out.append(_rotate_letter(ch, k))
+    elif ch.isdigit():
+      out.append(_rotate_digit(ch, k))
+    elif ch.isspace():
+      out.append(ch)
+    else:
+      out.append(_rotate_symbol(ch, k, principle))
+  return "".join(out)
+
+
+def decrypt(cipher: str, key: str, principle: Principle) -> str:
+  ks = _keystream(principle, key, len(cipher))
+  out = []
+  for i, ch in enumerate(cipher):
+    k = ks[i]
+    if ch.isalpha():
+      out.append(_rotate_letter(ch, -k))
+    elif ch.isdigit():
+      out.append(_rotate_digit(ch, -k))
+    elif ch.isspace():
+      out.append(ch)
+    else:
+      out.append(_rotate_symbol(ch, -k, principle))
+  return "".join(out)
+
+
+# Secure mode (optional dependency on 'cryptography')
+
+def _derive_key(passphrase: str, salt: bytes) -> bytes:
+  if not passphrase:
+    raise InputError("Key must be non-empty")
+  # 32-byte key via PBKDF2-HMAC-SHA256
+  from hashlib import pbkdf2_hmac
+  raw = pbkdf2_hmac('sha256', passphrase.encode('utf-8'), salt, 200_000, dklen=32)
+  return base64.urlsafe_b64encode(raw)
+
+
+def encrypt_secure(text: str, key: str) -> str:
+  try:
+    from cryptography.fernet import Fernet
+  except Exception as exc:  # pragma: no cover - optional dependency
+    raise InputError("Secure mode requires 'cryptography' package. Install it to use --mode secure.") from exc
+  salt = os.urandom(16)
+  f = Fernet(_derive_key(key, salt))
+  token = f.encrypt(text.encode('utf-8'))
+  payload = b'G9F' + salt + token
+  return base64.urlsafe_b64encode(payload).decode('ascii')
+
+
+def decrypt_secure(ciphertext: str, key: str) -> str:
+  try:
+    from cryptography.fernet import Fernet
+  except Exception as exc:  # pragma: no cover - optional dependency
+    raise InputError("Secure mode requires 'cryptography' package. Install it to use --mode secure.") from exc
+  try:
+    raw = base64.urlsafe_b64decode(ciphertext.encode('ascii'))
+  except Exception as exc:
+    raise InputError("Invalid secure ciphertext") from exc
+  if not raw.startswith(b'G9F') or len(raw) < 19:
+    raise InputError("Invalid secure ciphertext")
+  salt = raw[3:19]
+  token = raw[19:]
+  f = Fernet(_derive_key(key, salt))
+  try:
+    out = f.decrypt(token)
+  except Exception as exc:
+    raise InputError("Decryption failed; wrong key or corrupted data") from exc
+  return out.decode('utf-8')
+

gdk9/data/ninefold.json

@@ -0,0 +1,40 @@
+{
+  "name": "Ninefold Grid",
+  "description": "Default Gdk9 principle: A1Z26, digital-root numbers, curated symbol energies.",
+  "letter_mode": "a1z26",
+  "number_mode": "digital_root",
+  "normalize_zero_to_nine": true,
+  "weights": {"letter": 1, "digit": 1, "symbol": 1},
+  "harmonics": true,
+  "symbol_energy": {
+    ".": 1,
+    ",": 2,
+    "!": 3,
+    "?": 4,
+    ":": 5,
+    ";": 6,
+    "-": 7,
+    "_": 8,
+    "*": 9,
+    "#": 5,
+    "+": 4,
+    "=": 6,
+    "@": 8,
+    "$": 7,
+    "%": 5,
+    "&": 9,
+    "/": 3,
+    "\\": 3,
+    "(": 2,
+    ")": 2,
+    "[": 2,
+    "]": 2,
+    "{": 2,
+    "}": 2,
+    "<": 1,
+    ">": 1,
+    "|": 1,
+    "~": 9,
+    "^": 8
+  }
+}

gdk9/data/official.example.json

@@ -0,0 +1,16 @@
+{
+  "name": "Gdk9 Official (Example)",
+  "description": "Replace this file with your official mapping and rename to official.json to activate.",
+  "letter_mode": "a1z26",
+  "number_mode": "digital_root",
+  "normalize_zero_to_nine": true,
+  "weights": {"letter": 1, "digit": 1, "symbol": 1},
+  "harmonics": true,
+  "symbol_energy": {
+    ".": 1,
+    ",": 2,
+    "!": 3,
+    "?": 4
+  }
+}
+

gdk9/data/official.json

@@ -0,0 +1,132 @@
+{
+  "name": "Gdk9 Official",
+  "description": "Official GDk9 Implication Engine Mapping embedded alongside CLI principle fields.",
+  "letter_mode": "a1z26",
+  "number_mode": "digital_root",
+  "normalize_zero_to_nine": true,
+  "weights": {"letter": 1, "digit": 1, "symbol": 1},
+  "harmonics": true,
+  "symbol_energy": {
+    ".": 1,
+    ",": 2,
+    "!": 3,
+    "?": 4,
+    ":": 5,
+    ";": 6,
+    "-": 7,
+    "_": 8,
+    "*": 9,
+    "#": 5,
+    "+": 4,
+    "=": 6,
+    "@": 8,
+    "$": 7,
+    "%": 5,
+    "&": 9,
+    "/": 3,
+    "\\": 3,
+    "(": 2,
+    ")": 2,
+    "[": 2,
+    "]": 2,
+    "{": 2,
+    "}": 2,
+    "<": 1,
+    ">": 1,
+    "|": 1,
+    "~": 9,
+    "^": 8
+  },
+  "gdk9_mapping": {
+    "version": "0.1.0",
+    "spec": "GDk9 Implication Engine Mapping",
+    "updated_utc": "2025-10-22T00:00:00Z",
+    "units": {
+      "energy": "E",
+      "epsilon": 1e-9
+    },
+    "naming": {
+      "symbol_regex": "^[A-Z][A-Za-z0-9_]*$",
+      "rule_regex": "^[a-z][a-z0-9_]*$",
+      "reserved_symbols": ["E0", "NULL", "ONE"]
+    },
+    "layers": [
+      {"id": "L1", "name": "Physics↔Computation", "concepts": ["rest_energy", "landauer", "bit_energy_boundary"]},
+      {"id": "L2", "name": "Language↔Logic", "concepts": ["implication", "parse_tree", "normal_form"]},
+      {"id": "L3", "name": "Identity↔Access", "concepts": ["key_invariant", "signature", "policy_rule"]},
+      {"id": "L4", "name": "Games↔Economics", "concepts": ["token_energy", "score", "exchange_rule"]}
+    ],
+    "symbol": {
+      "fields": ["name", "energy"],
+      "constraints": {
+        "name": "must match naming.symbol_regex",
+        "energy": "float, finite"
+      },
+      "examples": [
+        {"name": "A", "energy": 2.0},
+        {"name": "B", "energy": 3.5}
+      ]
+    },
+    "conservation": {
+      "law": "sum(inputs.energy) == sum(outputs.energy)",
+      "tolerance": 1e-9,
+      "on_violation": "error:ConservationError"
+    },
+    "rules": {
+      "types": ["fusion", "split", "custom"],
+      "templates": {
+        "fusion": {
+          "arity": "n>=2",
+          "energy": "sum(inputs)",
+          "output": {"name": "concat(inputs.names)", "energy": "sum(inputs.energy)"}
+        },
+        "split": {
+          "arity": 1,
+          "params": {"ratio": "0..1"},
+          "outputs": [
+            {"name": "OUT_A", "energy": "E_in * ratio"},
+            {"name": "OUT_B", "energy": "E_in * (1-ratio)"}
+          ]
+        },
+        "custom": {
+          "arity": "n>=1",
+          "energy": "must conserve",
+          "definition": "user function(inputs)->outputs"
+        }
+      },
+      "id_hash": "sha256(name|arity|template|params)"
+    },
+    "cli_map": {
+      "symbol_add": "gdk9 symbol add <NAME> <ENERGY>",
+      "symbol_list": "gdk9 symbol list",
+      "rule_define_fusion": "gdk9 imply define-fusion <RULE> <OUT_NAME> <ARITY>",
+      "rule_define_split": "gdk9 imply define-split <RULE> <OUT_A> <OUT_B> <RATIO>",
+      "rule_list": "gdk9 imply list",
+      "rule_apply": "gdk9 imply apply <RULE> <INPUTS...>",
+      "repl": "gdk9 repl"
+    },
+    "storage": {
+      "path": "~/.gdk9/state.json",
+      "format": {
+        "symbols": {"<NAME>": "<ENERGY:float>"},
+        "rules": ["<RULE_NAME>"]
+      }
+    },
+    "telemetry": {
+      "log_fields": ["ts", "cmd", "inputs", "outputs", "ok"],
+      "privacy": "local-only in this build"
+    },
+    "examples": {
+      "fusion": {
+        "inputs": [{"name":"A","energy":2.0},{"name":"B","energy":3.0}],
+        "outputs": [{"name":"AB","energy":5.0}]
+      },
+      "split": {
+        "inputs": [{"name":"AB","energy":5.0}],
+        "params": {"ratio": 0.4},
+        "outputs": [{"name":"A","energy":2.0},{"name":"B","energy":3.0}]
+      }
+    }
+  }
+}
+