ethernium-continuity-pro 2.1.0__tar.gz

ethernium_continuity_pro-2.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Ethernium (X: @Steveblackbeard)
+
+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.
+

ethernium_continuity_pro-2.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: ethernium-continuity-pro
+Version: 2.1.0
+Summary: Continuity Legacy (Pro): Industrial-grade AI continuity framework with security audits and global synchronization.
+Author: SteveBlackbeard
+Project-URL: Homepage, https://github.com/SteveBlackbeard/CONTINUITY-LEGACY-by-Ethernium
+Project-URL: Bug Tracker, https://github.com/SteveBlackbeard/CONTINUITY-LEGACY-by-Ethernium/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]>=0.9.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: vector
+Requires-Dist: chromadb>=0.4.0; extra == "vector"
+Requires-Dist: sentence-transformers; extra == "vector"
+Provides-Extra: all
+Requires-Dist: chromadb>=0.4.0; extra == "all"
+Requires-Dist: sentence-transformers; extra == "all"
+Requires-Dist: networkx; extra == "all"
+Requires-Dist: rdflib; extra == "all"
+Dynamic: license-file
+
+# Continuity Pro (v2.1.0) - Tactical Evolution Engine
+
+
+
+[![Version](https://img.shields.io/badge/version-2.1.0-blue.svg)](https://github.com/SteveBlackbeard/CONTINUITY-LEGACY-by-Ethernium)
+
+[![Requirement](https://img.shields.io/badge/hardware-standard-orange.svg)](https://github.com/SteveBlackbeard/CONTINUITY-LEGACY-by-Ethernium)
+
+
+
+**Pro** is the industry-grade motor for tactical context synchronization and architectural auditing.
+
+
+
+---
+
+
+
+##  Installation (Quick)
+
+
+
+```bash
+
+# Install the Pro edition from its folder
+
+pip install -e .
+
+
+
+# Setup the Git DNA Guardian Entry Point
+
+continuity-pro --hook
+
+```
+
+
+
+---
+
+
+
+##  Minimal Usage
+
+
+
+```bash
+
+# Run the tactical audit cycle in strict mode
+
+continuity-pro --strict
+
+```
+
+
+
+---
+
+
+
+##  Hardware Profile
+
+- **CPU**: Standard Multicore.
+
+- **RAM**: 4GB+ Recommended.
+
+- **Python**: 3.9+ (External packages for sync/sanitization).
+
+
+
+---
+
+*Continuity: Protecting the logical lineage of your software.*
+

ethernium_continuity_pro-2.1.0/README.md

@@ -0,0 +1,37 @@
+# Continuity Pro (v2.1.0) - Tactical Evolution Engine
+
+[![Version](https://img.shields.io/badge/version-2.1.0-blue.svg)](https://github.com/SteveBlackbeard/CONTINUITY-LEGACY-by-Ethernium)
+[![Requirement](https://img.shields.io/badge/hardware-standard-orange.svg)](https://github.com/SteveBlackbeard/CONTINUITY-LEGACY-by-Ethernium)
+
+**Pro** is the industry-grade motor for tactical context synchronization and architectural auditing.
+
+---
+
+##  Installation (Quick)
+
+```bash
+# Install the Pro edition from its folder
+pip install -e .
+
+# Setup the Git DNA Guardian Entry Point
+continuity-pro --hook
+```
+
+---
+
+##  Minimal Usage
+
+```bash
+# Run the tactical audit cycle in strict mode
+continuity-pro --strict
+```
+
+---
+
+##  Hardware Profile
+- **CPU**: Standard Multicore.
+- **RAM**: 4GB+ Recommended.
+- **Python**: 3.9+ (External packages for sync/sanitization).
+
+---
+*Continuity: Protecting the logical lineage of your software.*

ethernium_continuity_pro-2.1.0/continuity_pro/continuity_legacy/__init__.py

@@ -0,0 +1 @@
+"""Core helpers for Continuity Legacy."""

ethernium_continuity_pro-2.1.0/continuity_pro/continuity_legacy/archive_manager.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+archive_manager.py — CONTINUITY LEGACY Pro
+==========================================
+Systemic Log Rotation & Context Archiving.
+
+Moves historical outputs and oversized log files from .continuity/ 
+to .continuity/archive/ to prevent context window saturation while 
+preserving the project's 'Genetic Code'.
+"""
+
+import os
+import json
+import shutil
+import datetime
+from pathlib import Path
+
+# Config
+MAX_LOG_SIZE_BYTES = 50 * 1024  # 50KB threshold for rotation
+ARCHIVE_DIR_NAME = "archive"
+
+def rotate_logs(repo_root: Path):
+    print(f"[*] Archive Manager: Evaluating log health in {repo_root}...")
+    
+    continuity_dir = repo_root / ".continuity"
+    archive_dir = continuity_dir / ARCHIVE_DIR_NAME
+    
+    if not continuity_dir.exists():
+        print("[!] No .continuity directory found. Skipping archiving.")
+        return
+
+    archive_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Files to track for rotation
+    targets = [
+        "DECISIONS_LOG.md",
+        "TIMELINE.md",
+    ]
+    
+    for target in targets:
+        file_path = continuity_dir / target
+        if file_path.exists() and file_path.stat().st_size > MAX_LOG_SIZE_BYTES:
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            archive_name = f"{target.replace('.md', '')}_{timestamp}.md"
+            dest_path = archive_dir / archive_name
+            
+            print(f"  [>] Rotating {target} (Size: {file_path.stat().st_size} bytes)")
+            shutil.copy2(file_path, dest_path)
+            
+            # Reset the active file with a link to the archive
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(f"# {target.replace('.md', '').replace('_', ' ')}\n")
+                f.write(f"> [!] LOG ROTATED on {timestamp}. See archive/{archive_name} for history.\n\n")
+            
+    # Cleanup old cycle reports in outputs
+    outputs_dir = repo_root / "outputs" / "continuity"
+    if outputs_dir.exists():
+        # Keep only the last 10 reports, archive the rest? Or just prune.
+        # For '' we archive them.
+        report_archive = archive_dir / "reports"
+        report_archive.mkdir(exist_ok=True)
+        
+        all_reports = sorted(list(outputs_dir.glob("*.json")), key=os.path.getmtime)
+        if len(all_reports) > 10:
+            to_archive = all_reports[:-10]
+            print(f"  [>] Archiving {len(to_archive)} historical reports...")
+            for r in to_archive:
+                shutil.move(str(r), str(report_archive / r.name))
+
+    print("[✔] Archiving Cycle Complete.")
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="Rotate and archive continuity logs.")
+    parser.add_argument("--repo-root", default=".", help="Root directory of the project")
+    args = parser.parse_args()
+    rotate_logs(Path(args.repo_root).resolve())

ethernium_continuity_pro-2.1.0/continuity_pro/continuity_legacy/automation_common.py

@@ -0,0 +1,339 @@
+from __future__ import annotations
+
+import json
+from copy import deepcopy
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+class Color:
+    """Terminal color constants for standardized elite CLI feedback."""
+    PURPLE = "\033[95m"
+    CYAN = "\033[96m"
+    DARKCYAN = "\033[36m"
+    BLUE = "\033[94m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    RED = "\033[91m"
+    WHITE = "\033[97m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+    END = "\033[0m"
+
+
+def echo(text: str, color: str = "") -> None:
+    """Prints text to the console with optional color formatting.
+
+    Args:
+        text: The string to be printed.
+        color: The ANSI color code to apply (e.g., Color.GREEN).
+    """
+    if color:
+        print(f"{color}{text}{Color.END}")
+    else:
+        print(text)
+
+
+DEFAULT_CONFIG = {
+    "template_name": "CONTINUITY LEGACY",
+    "project_name": "YOUR_PROJECT",
+    "project_slug": "your_project",
+    "context_file": "PROJECT_CONTEXT.md",
+    "state_file": "STATE.json",
+    "roadmap_file": "ROADMAP.md",
+    "continuity_dir": ".continuity",
+    "outputs_dir": "outputs/continuity",
+    "external_docs": {
+        "enabled": False,
+        "folder_name": "YOUR_PROJECTDEV",
+        "root_override": "",
+    },
+    "metadata": {
+        "generated_by": "Continuity Legacy by Ethernium",
+        "tool_version": "5.0.0",
+        "creator": "@Steveblackbeard",
+        "include_in_reports": True,
+    },
+}
+
+ALLOWED_MEMBERSHIP_STATUSES = [
+    "canonical",
+    "bridge",
+    "archive_source",
+    "external_optional",
+]
+
+# v2.1.1 Crystallization: Governance Thresholds
+ENTROPY_THRESHOLD = 6.5  # Bits per character (Shannon Entropy)
+
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def resolve_repo_root(repo_root: str | Path | None, current_file: str | Path) -> Path:
+    if repo_root:
+        return Path(repo_root).resolve()
+    
+    # v2.1.1: Intelligent Upward Discovery to protect hierarchy sovereignty
+    start_path = Path(current_file).resolve().parent
+    for parent in [start_path] + list(start_path.parents):
+        if (parent / "continuity-legacy.json").exists() or (parent / ".continuity").exists():
+            return parent
+            
+    # Fallback safe: current branch root
+    return start_path.parents[2]
+
+
+def load_config(repo_root: Path) -> dict:
+    """Loads and merges the continuity-legacy.json configuration.
+
+    Args:
+        repo_root: The filesystem path to the root of the project.
+
+    Returns:
+        A dictionary containing the merged project configuration.
+    """
+    config_file = repo_root / "continuity-legacy.json"
+    payload = {}
+    if config_file.exists():
+        payload = json.loads(config_file.read_text(encoding="utf-8"))
+    
+    return _deep_merge(DEFAULT_CONFIG, payload)
+
+
+def save_config(repo_root: Path, config: dict) -> None:
+    """Saves the continuity-legacy.json configuration to the repository root.
+
+    Args:
+        repo_root: The filesystem path to the root of the project.
+        config: The configuration dictionary to persist.
+    """
+    config_file = repo_root / "continuity-legacy.json"
+    config_file.write_text(json.dumps(config, indent=2), encoding="utf-8")
+
+
+def config_path(repo_root: str | Path) -> Path:
+    return Path(repo_root) / "continuity_legacy.json"
+
+
+def read_text(path: str | Path) -> str:
+    return Path(path).read_text(encoding="utf-8", errors="ignore")
+
+
+def write_text(path: str | Path, content: str) -> None:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(content.rstrip() + "\n", encoding="utf-8")
+
+
+def read_json(path: str | Path, default: Any | None = None) -> Any:
+    file_path = Path(path)
+    if not file_path.exists():
+        return deepcopy(default)
+    return json.loads(file_path.read_text(encoding="utf-8"))
+
+
+def write_json(path: str | Path, payload: Any) -> None:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps(payload, indent=2, ensure_ascii=True), encoding="utf-8")
+
+
+def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    merged = deepcopy(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = _deep_merge(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def build_context_snapshot(repo_root: Path, external_root_override: Path | None = None) -> dict:
+    """Builds a comprehensive snapshot of the project context from multiple sources.
+
+    Args:
+        repo_root: The root directory of the project.
+        external_root_override: Optional path to an external documentation root.
+
+    Returns:
+        A dictionary containing the aggregated 'truth' of the project.
+    """
+    config = load_config(repo_root)
+    state = read_json(state_path(repo_root, config), {})
+    context_text = read_text(context_path(repo_root, config))
+    roadmap_text = read_text(roadmap_path(repo_root, config))
+
+    return {
+        "project_name": config.get("project_name"),
+        "project_slug": config.get("project_slug"),
+        "phase": state.get("status", "unknown"),
+        "next_actions": state.get("next_actions", []),
+        "context_summary": context_text[:2000],
+        "roadmap_summary": roadmap_text[:2000],
+        "last_decision": state.get("last_decision", "none"),
+        "timestamp": utc_now_iso(),
+    }
+
+
+def context_path(repo_root: str | Path, config: dict[str, Any] | None = None) -> Path:
+    config = config or load_config(repo_root)
+    return Path(repo_root) / config["context_file"]
+
+
+def state_path(repo_root: str | Path, config: dict[str, Any] | None = None) -> Path:
+    config = config or load_config(repo_root)
+    return Path(repo_root) / config["state_file"]
+
+
+def roadmap_path(repo_root: str | Path, config: dict[str, Any] | None = None) -> Path:
+    config = config or load_config(repo_root)
+    return Path(repo_root) / config["roadmap_file"]
+
+
+def continuity_dir(repo_root: str | Path, config: dict[str, Any] | None = None) -> Path:
+    config = config or load_config(repo_root)
+    return Path(repo_root) / config["continuity_dir"]
+
+
+def continuity_doc_path(repo_root: str | Path, name: str, config: dict[str, Any] | None = None) -> Path:
+    return continuity_dir(repo_root, config) / name
+
+
+def outputs_dir(repo_root: str | Path, config: dict[str, Any] | None = None) -> Path:
+    config = config or load_config(repo_root)
+    return Path(repo_root) / config["outputs_dir"]
+
+
+def bootstrap_output_path(repo_root: str | Path, config: dict[str, Any] | None = None) -> Path:
+    return outputs_dir(repo_root, config) / "context_bootstrap_summary.json"
+
+
+def continuity_report_path(repo_root: str | Path, config: dict[str, Any] | None = None) -> Path:
+    return outputs_dir(repo_root, config) / "continuity_cycle_report.json"
+
+
+def dependency_map_path(repo_root: str | Path, config: dict[str, Any] | None = None) -> Path:
+    return continuity_dir(repo_root, config) / "registry" / "document_dependency_map.json"
+
+
+def membership_registry_path(repo_root: str | Path, config: dict[str, Any] | None = None) -> Path:
+    return continuity_dir(repo_root, config) / "registry" / "system_membership_registry.json"
+
+
+def load_dependency_map(repo_root: str | Path, config: dict[str, Any] | None = None) -> dict[str, Any]:
+    return read_json(dependency_map_path(repo_root, config), {"version": "1.0", "documents": []}) or {
+        "version": "1.0",
+        "documents": [],
+    }
+
+
+def load_membership_registry(repo_root: str | Path, config: dict[str, Any] | None = None) -> dict[str, Any]:
+    return read_json(
+        membership_registry_path(repo_root, config),
+        {
+            "version": "1.0",
+            "allowed_statuses": ALLOWED_MEMBERSHIP_STATUSES,
+            "entries": [],
+        },
+    ) or {
+        "version": "1.0",
+        "allowed_statuses": ALLOWED_MEMBERSHIP_STATUSES,
+        "entries": [],
+    }
+
+
+def is_ignored(repo_root: str | Path, rel_path: str) -> bool:
+    ignore_file = Path(repo_root) / ".continuityignore"
+    if not ignore_file.exists():
+        return False
+    
+    import fnmatch
+    patterns = [line.strip() for line in ignore_file.read_text(encoding="utf-8").splitlines() if line.strip() and not line.startswith("#")]
+    for pattern in patterns:
+        if fnmatch.fnmatch(rel_path, pattern):
+            return True
+    return False
+
+
+def external_root(
+    repo_root: str | Path,
+    config: dict[str, Any] | None = None,
+    override: str | Path | None = None,
+) -> Path | None:
+    config = config or load_config(repo_root)
+    external_cfg = config.get("external_docs", {})
+    if override:
+        return Path(override).resolve()
+    root_override = str(external_cfg.get("root_override") or "").strip()
+    if root_override:
+        return Path(root_override).resolve()
+    if not external_cfg.get("enabled"):
+        return None
+    return Path(repo_root).resolve().parent / str(external_cfg.get("folder_name") or "PROJECTDEV")
+
+
+def calculate_sha256(path: str | Path) -> str:
+    """Calculates the SHA-256 hash of a file for high-fidelity DNA synthesis."""
+    import hashlib
+    p = Path(path)
+    if not p.exists():
+        return ""
+    return hashlib.sha256(p.read_bytes()).hexdigest()
+
+
+def build_merkle_tree(hashes: list[str]) -> str:
+    """RFC 6962 compliant Merkle Tree with leaf/node prefix hardening.
+    
+    Uses deterministic sorting and prefixed hashing:
+    - Leaf nodes: H(0x00 || data)  
+    - Internal nodes: H(0x01 || left || right)
+    
+    This prevents second-preimage attacks where an attacker crafts
+    a different input set that produces the same root hash.
+    """
+    import hashlib
+    if not hashes:
+        return "0" * 64
+    
+    # Leaf nodes: H(0x00 || data)
+    current_level = [hashlib.sha256(b"\x00" + h.encode("utf-8")).hexdigest() for h in sorted(hashes)]
+    
+    while len(current_level) > 1:
+        next_level = []
+        if len(current_level) % 2 != 0:
+            current_level.append(current_level[-1])
+            
+        for i in range(0, len(current_level), 2):
+            # Internal nodes: H(0x01 || left || right)
+            combined = b"\x01" + (current_level[i] + current_level[i+1]).encode("utf-8")
+            next_level.append(hashlib.sha256(combined).hexdigest())
+        current_level = next_level
+        
+    return current_level[0]
+
+# Alias for backward compatibility
+build_merkle_root = build_merkle_tree
+
+
+def calculate_context_entropy(text: str) -> float:
+    """Calculates the Shannon Entropy of a text block to measure context volatility."""
+    import math
+    if not text:
+        return 0.0
+    
+    # Calculate frequencies
+    freqs = {}
+    for char in text:
+        freqs[char] = freqs.get(char, 0) + 1
+    
+    # Shannon Entropy formula
+    length = len(text)
+    entropy = 0.0
+    for count in freqs.values():
+        p = count / length
+        entropy -= p * math.log2(p)
+        
+    return entropy

ethernium_continuity_pro-2.1.0/continuity_pro/continuity_legacy/bootstrap_context.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from core.automation_common import bootstrap_output_path, resolve_repo_root
+from core.context_loader import build_context_snapshot, summarize_snapshot
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Build a continuity snapshot for the current project.")
+    parser.add_argument("--repo-root", default=None)
+    parser.add_argument("--output-json", default=None)
+    parser.add_argument("--external-root", default=None)
+    parser.add_argument("--no-print", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    repo_root = resolve_repo_root(args.repo_root, __file__)
+    snapshot = build_context_snapshot(repo_root, args.external_root)
+    output_path = bootstrap_output_path(repo_root)
+    if args.output_json:
+        output_path = Path(args.output_json)
+        if not output_path.is_absolute():
+            output_path = repo_root / output_path
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(snapshot, indent=2, ensure_ascii=True), encoding="utf-8")
+    if not args.no_print:
+        print(summarize_snapshot(snapshot))
+
+
+if __name__ == "__main__":
+    main()