superlocalmemory 2.8.6 → 3.0.0

package/src/qualixar_attribution.py

@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-# Part of Qualixar — Advancing Agent Development Through Research
-"""
-Qualixar Attribution — Cryptographic output signing for provenance tracking.
-
-Signs tool outputs with SHA-256 content hashes and verifiable provenance
-metadata. Part of the 3-layer Qualixar attribution system:
-  Layer 1: Visible attribution (ATTRIBUTION.md, get_attribution())
-  Layer 2: Cryptographic signing (this module)
-  Layer 3: Steganographic watermarking (qualixar_watermark.py)
-"""
-
-import hashlib
-import json
-import time
-from typing import Any, Dict
-
-
-# Registry of all Qualixar research initiative tools
-TOOL_REGISTRY: Dict[str, str] = {
-    "agentassert": "AgentAssert — Behavioral Contracts",
-    "agentassay": "AgentAssay — Stochastic Testing",
-    "skillfortify": "SkillFortify — Security Validation",
-    "superlocalmemory": "SuperLocalMemory — Agent Memory",
-    "telephonebench": "TelephoneBench — Communication Benchmarks",
-    "vibecheck": "VibeCheck — Code Reliability",
-    "agentreplay": "AgentReplay — Time-Travel Debugging",
-    "agentchaos": "AgentChaos — Chaos Engineering",
-    "agentmigrate": "AgentMigrate — Migration Engineering",
-    "agentpact": "AgentPact — Composition Testing",
-}
-
-
-class QualixarSigner:
-    """Signs tool outputs with cryptographic provenance metadata.
-
-    Adds a ``_qualixar`` block to output dictionaries containing a SHA-256
-    content hash, timestamp, tool information, and a verifiable signature.
-
-    Args:
-        tool_name: Identifier for the tool (e.g. ``"superlocalmemory"``).
-        version: Semantic version string of the tool.
-
-    Example::
-
-        signer = QualixarSigner("superlocalmemory", "2.8.3")
-        signed = signer.sign({"memories": [...]})
-        assert QualixarSigner.verify(signed) is True
-    """
-
-    def __init__(self, tool_name: str, version: str) -> None:
-        self.tool_name = tool_name
-        self.version = version
-        self.tool_desc = TOOL_REGISTRY.get(tool_name, tool_name)
-
-    def sign(self, output_data: Any) -> Dict[str, Any]:
-        """Add cryptographic provenance to any output.
-
-        Args:
-            output_data: The data to sign. If a dict, provenance is added
-                in-place. Otherwise wrapped in ``{"data": ...}``.
-
-        Returns:
-            Dictionary with the original data plus a ``_qualixar`` provenance
-            block containing content_hash, timestamp, and signature.
-        """
-        timestamp = time.time()
-        canonical = json.dumps(output_data, sort_keys=True, default=str)
-        content_hash = hashlib.sha256(canonical.encode()).hexdigest()
-
-        provenance = {
-            "_qualixar": {
-                "tool": self.tool_name,
-                "tool_description": self.tool_desc,
-                "version": self.version,
-                "platform": "Qualixar",
-                "timestamp": timestamp,
-                "content_hash": content_hash,
-                "license": "MIT",
-                "attribution": (
-                    f"Generated by {self.tool_desc} v{self.version}"
-                ),
-                "signature": self._compute_signature(
-                    content_hash, timestamp
-                ),
-            }
-        }
-
-        if isinstance(output_data, dict):
-            output_data.update(provenance)
-            return output_data
-        return {"data": output_data, **provenance}
-
-    def _compute_signature(
-        self, content_hash: str, timestamp: float
-    ) -> str:
-        """Compute HMAC-style signature over content hash and timestamp.
-
-        In production, this should use Ed25519 with a private key.
-        The current implementation uses SHA-256 over a canonical string
-        as a lightweight integrity check.
-
-        Args:
-            content_hash: SHA-256 hex digest of the canonical content.
-            timestamp: Unix timestamp of signing.
-
-        Returns:
-            Hex-encoded SHA-256 signature string.
-        """
-        sig_input = (
-            f"{self.tool_name}:{self.version}:"
-            f"{content_hash}:{timestamp}"
-        )
-        return hashlib.sha256(sig_input.encode()).hexdigest()
-
-    @staticmethod
-    def verify(output_data: Dict[str, Any]) -> bool:
-        """Verify an output's provenance signature.
-
-        Re-computes the content hash from the non-provenance fields and
-        compares it against the hash stored in the ``_qualixar`` block.
-
-        Args:
-            output_data: A dictionary previously signed with :meth:`sign`.
-
-        Returns:
-            ``True`` if the content hash matches, ``False`` otherwise.
-        """
-        prov = output_data.get("_qualixar", {})
-        if not prov:
-            return False
-        content = {
-            k: v for k, v in output_data.items() if k != "_qualixar"
-        }
-        canonical = json.dumps(content, sort_keys=True, default=str)
-        expected_hash = hashlib.sha256(canonical.encode()).hexdigest()
-        return prov.get("content_hash") == expected_hash

package/src/qualixar_watermark.py

@@ -1,78 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-# Part of Qualixar — Advancing Agent Development Through Research
-"""
-Qualixar Watermark — Steganographic attribution for text outputs.
-
-Embeds invisible zero-width Unicode characters in text to encode a tool
-identifier. The watermark is invisible to human readers but can be
-extracted programmatically to verify provenance.
-
-Part of the 3-layer Qualixar attribution system:
-  Layer 1: Visible attribution (ATTRIBUTION.md, get_attribution())
-  Layer 2: Cryptographic signing (qualixar_attribution.py)
-  Layer 3: Steganographic watermarking (this module)
-
-No external dependencies required.
-"""
-
-# Zero-width characters for binary encoding
-ZW_SPACE = '\u200b'    # Zero-width space  = bit 0
-ZW_JOINER = '\u200d'   # Zero-width joiner = bit 1
-ZW_SEP = '\ufeff'      # Byte order mark   = separator
-
-
-def encode_watermark(text: str, tool_id: str) -> str:
-    """Embed an invisible watermark in text output.
-
-    Converts ``tool_id`` to binary and encodes each bit as a zero-width
-    Unicode character. The watermark is inserted after the first paragraph
-    break (``\\n\\n``) so it remains invisible to human readers.
-
-    Args:
-        text: The text to watermark.
-        tool_id: Short identifier to embed (e.g. ``"slm"``).
-
-    Returns:
-        The original text with the invisible watermark inserted.
-    """
-    binary = ''.join(format(ord(c), '08b') for c in tool_id)
-    watermark = ZW_SEP
-    for bit in binary:
-        watermark += ZW_SPACE if bit == '0' else ZW_JOINER
-    watermark += ZW_SEP
-
-    # Insert after first paragraph break (invisible to users)
-    if '\n\n' in text:
-        idx = text.index('\n\n') + 2
-        return text[:idx] + watermark + text[idx:]
-    return text + watermark
-
-
-def decode_watermark(text: str) -> str:
-    """Extract a hidden watermark from text.
-
-    Locates the zero-width separator characters and decodes the binary
-    payload between them back into the original tool identifier string.
-
-    Args:
-        text: Text that may contain a watermark.
-
-    Returns:
-        The decoded tool identifier, or an empty string if no watermark
-        is found.
-    """
-    start = text.find(ZW_SEP)
-    if start == -1:
-        return ""
-    end = text.find(ZW_SEP, start + 1)
-    if end == -1:
-        return ""
-    encoded = text[start + 1:end]
-    binary = ''.join(
-        '0' if c == ZW_SPACE else '1'
-        for c in encoded
-    )
-    chars = [binary[i:i + 8] for i in range(0, len(binary), 8)]
-    return ''.join(chr(int(b, 2)) for b in chars if len(b) == 8)