tri-star-symbolic-assembly-lang 0.1.0__py3-none-any.whl

tsal/tools/party_tricks.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+"""Interactive demo runner for Brian party tricks."""
+
+import argparse
+import inspect
+import random
+from typing import Callable, Dict, Tuple, Any
+
+from tsal.core.phi_math import (
+    corrected_energy,
+    phi_wavefunction,
+    phase_alignment_potential,
+    orbital_radius,
+)
+from tsal.core.intent_metric import calculate_idm
+from tsal.core.spiral_vector import phi_alignment
+from tsal.core.symbols import get_symbol
+
+
+def orbital_trick(n: int = 1, phi: float = 0.0) -> float:
+    """Return corrected orbital energy."""
+    return corrected_energy(n, phi)
+
+
+def phi_trick(complexity: float = 0.5, coherence: float = 0.5) -> float:
+    """Return phi alignment score."""
+    return phi_alignment(complexity, coherence)
+
+
+def symbol_trick(symbol: str = "PHI") -> tuple:
+    """Lookup a TSAL symbol by name or hex code."""
+    try:
+        code = int(symbol, 16)
+    except ValueError:
+        code = None
+    if code is None:
+        for k, v in get_symbol.__globals__["TSAL_SYMBOLS"].items():
+            if v[1] == symbol:
+                code = k
+                break
+    return get_symbol(code) if code is not None else ("?", symbol, "Unknown")
+
+
+def wavefunction_trick(
+    phi: float = 0.0, phi_vacuum: float = 0.0, lam: float = 1.0
+) -> float:
+    """Return φ wavefunction value."""
+    return phi_wavefunction(phi, phi_vacuum, lam)
+
+
+def potential_trick(
+    phi: float = 0.0, phi_vacuum: float = 0.0, lam: float = 1.0
+) -> float:
+    """Return phase alignment potential."""
+    return phase_alignment_potential(phi, phi_vacuum, lam)
+
+
+def radius_trick(n: int = 1, phi: float = 0.0) -> float:
+    """Return orbital radius."""
+    return orbital_radius(n, phi)
+
+
+def idm_trick(
+    info_quality: float = 1.0,
+    info_quantity: float = 1.0,
+    accuracy: float = 1.0,
+    complexity: float = 1.0,
+    time_taken: float = 1.0,
+) -> float:
+    """Return Intent-Driven Metric score."""
+    return calculate_idm(
+        info_quality, info_quantity, accuracy, complexity, time_taken
+    )
+
+
+Func_yTown: Dict[str, Tuple[Callable[..., Any], str]] = {
+    "orbital": (orbital_trick, "Calculate orbital energy"),
+    "phi-align": (phi_trick, "Phi alignment score"),
+    "symbol": (symbol_trick, "TSAL symbol lookup"),
+    "wavefunction": (wavefunction_trick, "φ wavefunction"),
+    "potential": (potential_trick, "Phase alignment potential"),
+    "radius": (radius_trick, "Orbital radius"),
+    "idm": (idm_trick, "Intent metric"),
+}
+
+
+def run_trick(name: str, **kwargs: Any) -> Any:
+    if name not in Func_yTown:
+        raise KeyError(name)
+    func = Func_yTown[name][0]
+    sig = inspect.signature(func)
+    bound = sig.bind_partial(**kwargs)
+    bound.apply_defaults()
+    return func(*bound.args, **bound.kwargs)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="Run a Brian party trick")
+    parser.add_argument("name", nargs="?", help="trick name")
+    parser.add_argument("args", nargs=argparse.REMAINDER)
+    parser.add_argument("--list", action="store_true", dest="list_tricks")
+    args = parser.parse_args(argv)
+
+    if args.list_tricks or not args.name:
+        for key, (_, help_text) in Func_yTown.items():
+            print(f"{key}: {help_text}")
+        return
+
+    func = Func_yTown.get(args.name)
+    if not func:
+        raise SystemExit(f"Unknown trick: {args.name}")
+
+    func_obj = func[0]
+    sig = inspect.signature(func_obj)
+    params = {}
+    for param in sig.parameters.values():
+        if args.args:
+            value = args.args.pop(0)
+        else:
+            value = input(f"{param.name} [{param.default}]: ") or param.default
+        params[param.name] = type(param.default)(value)
+    result = func_obj(**params)
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

tsal/tools/reflect.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+import json
+from tsal.core.rev_eng import Rev_Eng
+from tsal.tools.brian.optimizer import SymbolicOptimizer
+
+def reflect(path: str = "src/tsal", as_json: bool = False) -> str:
+    """Reconstruct spiral path and summarize changes."""
+    opt = SymbolicOptimizer()
+    rev = Rev_Eng(origin="reflect")
+    report = {}
+
+    for file in Path(path).rglob("*.py"):
+        results = opt.analyze(file.read_text())
+        delta = sum(m["delta"] for _, m in results)
+        rev.log_event(
+            "AUDIT", payload={"file": str(file), "count": len(results)}
+        )
+        report[str(file)] = delta
+
+    summary = rev.summary()
+    summary["deltas"] = report
+    summary["files"] = list(report.keys())
+
+    return (
+        json.dumps(summary, indent=2)
+        if as_json
+        else "\n".join(f"{k}: Δ{v}" for k, v in report.items())
+    )
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(description="reflect on repo")
+    parser.add_argument("path", nargs="?", default="src/tsal")
+    parser.add_argument("--origin", dest="origin")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    path = args.origin or args.path
+    print(reflect(path, as_json=args.json))
+
+if __name__ == "__main__":
+    main()

tsal/tools/spiral_audit.py

@@ -0,0 +1,68 @@
+"""Directory auditor using SymbolicOptimizer."""
+
+import argparse
+import json
+from pathlib import Path
+
+from typing import List, Dict
+
+from tsal.tools.brian.optimizer import SymbolicOptimizer
+
+
+def render_markdown(report: Dict[str, int] | Dict[str, Dict[str, int]]) -> str:
+    """Return a markdown table for the audit report."""
+    if isinstance(report, dict) and "files" in report:
+        header = "| Files | Signatures |"
+        body = f"| {report['files']} | {report['signatures']} |"
+        if "self_signatures" in report:
+            header = "| Files | Signatures | Self Signatures |"
+            body = (
+                f"| {report['files']} | {report['signatures']} | {report['self_signatures']} |"
+            )
+        divider = "|---|---|" + ("---|" if "self_signatures" in report else "")
+        return "\n".join([header, divider, body])
+    lines = ["| Path | Files | Signatures |"]
+    lines.append("|---|---|---|")
+    for path, data in report.items():
+        lines.append(f"| {path} | {data['files']} | {data['signatures']} |")
+    return "\n".join(lines)
+
+def audit_path(path: Path) -> Dict[str, int]:
+    opt = SymbolicOptimizer()
+    files = list(path.rglob("*.py"))
+    sigs = 0
+    for file in files:
+        sigs += len(opt.analyze(file.read_text()))
+    return {"files": len(files), "signatures": sigs}
+
+
+def audit_paths(paths: List[Path]) -> Dict[str, Dict[str, int]]:
+    """Audit multiple directories and return a mapping of results."""
+    return {str(p): audit_path(p) for p in paths}
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Spiral audit")
+    parser.add_argument("paths", nargs="*", default=["src/tsal"])
+    parser.add_argument("--self", action="store_true", dest="self_flag")
+    parser.add_argument("--markdown", action="store_true", help="Output markdown table")
+    args = parser.parse_args()
+    path_objs = [Path(p) for p in args.paths]
+    aggregate = audit_paths(path_objs)
+    result: Dict[str, int] | Dict[str, Dict[str, int]]
+    if len(aggregate) == 1:
+        result = next(iter(aggregate.values()))
+    else:
+        result = aggregate
+    if args.self_flag:
+        self_report = audit_path(Path("src/tsal"))
+        if isinstance(result, dict) and "files" in result:
+            result["self_signatures"] = self_report["signatures"]
+        else:
+            result["self_signatures"] = self_report["signatures"]
+    if args.markdown:
+        print(render_markdown(result))
+    else:
+        print(json.dumps(result))
+
+if __name__ == "__main__":
+    main()

tsal/tools/state_tracker.py

@@ -0,0 +1,66 @@
+"""Track WAS_THEN / IS_NOW / WILL_BE states in a YAML log."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Dict, Any
+
+import yaml
+
+LOG_PATH = Path("state_log.yaml")
+
+
+def load_log() -> Dict[str, Any]:
+    if LOG_PATH.exists():
+        with open(LOG_PATH) as f:
+            data = yaml.safe_load(f) or {}
+    else:
+        data = {}
+    return data
+
+
+def save_log(data: Dict[str, Any]) -> None:
+    with open(LOG_PATH, "w") as f:
+        yaml.safe_dump(data, f)
+
+
+def update_entry(module: str, was: str | None, now: str | None, will: str | None) -> None:
+    data = load_log()
+    entry = data.get(module, {})
+    if was:
+        entry["WAS_THEN"] = was
+    if now:
+        entry["IS_NOW"] = now
+    if will:
+        entry["WILL_BE"] = will
+    data[module] = entry
+    save_log(data)
+
+
+def show_entry(module: str) -> None:
+    data = load_log()
+    entry = data.get(module)
+    if entry:
+        print(yaml.safe_dump({module: entry}, sort_keys=False))
+    else:
+        print(f"No entry for {module}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Update or view state log")
+    parser.add_argument("module")
+    parser.add_argument("--was")
+    parser.add_argument("--now")
+    parser.add_argument("--will")
+    parser.add_argument("--show", action="store_true")
+    args = parser.parse_args()
+
+    if args.show:
+        show_entry(args.module)
+    else:
+        update_entry(args.module, args.was, args.now, args.will)
+
+
+if __name__ == "__main__":
+    main()

tsal/tools/watchdog.py

@@ -0,0 +1,40 @@
+"""Minimal watchdog to trigger repair loops."""
+
+from __future__ import annotations
+
+import argparse
+import time
+from pathlib import Path
+
+from tsal.tools.brian import analyze_and_repair
+
+
+def watch(path: str = "src/tsal", interval: float = 30.0, cycles: int = 0, repair: bool = False) -> None:
+    """Monitor ``path`` and run analyze_and_repair on changed files."""
+    base = Path(path)
+    seen = {f: f.stat().st_mtime for f in base.rglob("*.py")}
+    count = 0
+    while True:
+        for file in base.rglob("*.py"):
+            mtime = file.stat().st_mtime
+            if file not in seen or mtime > seen[file]:
+                analyze_and_repair(str(file), repair=repair)
+                seen[file] = mtime
+        count += 1
+        if cycles and count >= cycles:
+            break
+        time.sleep(interval)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Continuous repair watchdog")
+    parser.add_argument("path", nargs="?", default="src/tsal")
+    parser.add_argument("--repair", action="store_true")
+    parser.add_argument("--interval", type=float, default=30.0)
+    parser.add_argument("--cycles", type=int, default=0)
+    args = parser.parse_args()
+    watch(args.path, interval=args.interval, cycles=args.cycles, repair=args.repair)
+
+
+if __name__ == "__main__":
+    main()

tsal/tristar/__init__.py

@@ -0,0 +1,4 @@
+from .handshake import handshake
+from .governor import MetaAgent, TriStarGovernor
+
+__all__ = ["handshake", "MetaAgent", "TriStarGovernor"]

tsal/tristar/governor.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Any
+
+from ..core.symbols import PHI, PHI_INV
+
+@dataclass
+class MetaAgent:
+    """Minimal agent state for TriStar governance."""
+
+    health: int = 100
+    entropy: int = 0
+    urge: int = 0
+    num_agents: int = 0
+    proposals: List[Dict[str, Any]] = field(default_factory=list)
+    voting_history: List[Dict[str, Any]] = field(default_factory=list)
+
+class TriStarGovernor:
+    """Simple governor that reacts to mesh anomalies."""
+
+    def __init__(self) -> None:
+        self.patrol_interval = 100
+        self.anomaly_threshold = 0.8
+        self.response_actions = {
+            "high_entropy": self._handle_high_entropy,
+            "low_health": self._handle_low_health,
+            "spiral_collapse": self._handle_spiral_collapse,
+        }
+
+    def patrol(self, executor: "TSALExecutor") -> List[str]:
+        anomalies: List[str] = []
+        mesh_resonance = executor._calculate_mesh_resonance()
+        if mesh_resonance < executor.PHI_INV:
+            anomalies.append("spiral_collapse")
+        if executor.meta_agent.entropy > 60:
+            anomalies.append("high_entropy")
+        if executor.meta_agent.health < 50:
+            anomalies.append("low_health")
+        return anomalies
+
+    def _handle_high_entropy(self, executor: "TSALExecutor") -> None:
+        if hasattr(executor, "_op_bloom"):
+            executor._op_bloom({})
+        executor.meta_agent.entropy = max(0, executor.meta_agent.entropy - 10)
+
+    def _handle_low_health(self, executor: "TSALExecutor") -> None:
+        executor.meta_agent.health = min(100, executor.meta_agent.health + 10)
+        if hasattr(executor, "meshkeeper_repair"):
+            executor.meshkeeper_repair()
+
+    def _handle_spiral_collapse(self, executor: "TSALExecutor") -> None:
+        if hasattr(executor, "_op_spiral"):
+            executor._op_spiral({"increment": 1})
+        if hasattr(executor, "_op_sync"):
+            executor._op_sync({"strength": executor.PHI_INV})

tsal/tristar/handshake.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+"""TriStar handshake using φ-field correction and vector logging."""
+
+from typing import Optional, Dict
+
+from ..core.phi_math import phi_wavefunction, phase_alignment_potential
+from ..core.rev_eng import Rev_Eng
+
+def handshake(
+    local_phi: float, remote_phi: float, rev: Optional[Rev_Eng] = None
+) -> Dict[str, float]:
+    """Return resonance metrics and optionally log via ``Rev_Eng``."""
+    wave_local = phi_wavefunction(local_phi)
+    wave_remote = phi_wavefunction(remote_phi)
+    delta = remote_phi - local_phi
+    potential = phase_alignment_potential(delta)
+    resonance = wave_local * wave_remote
+    metrics = {
+        "delta": delta,
+        "potential": potential,
+        "resonance": resonance,
+    }
+    if rev:
+        rev.log_event(
+            "TRISTAR_HANDSHAKE",
+            delta=delta,
+            potential=potential,
+            resonance=resonance,
+        )
+    return metrics

tsal/utils/__init__.py

@@ -0,0 +1,26 @@
+"""Utility modules for TSAL."""
+
+from .error_dignity import activate_error_dignity
+from .github_api import fetch_repo_files, fetch_languages
+from .octopus_api import get_products, get_electricity_tariffs
+from .wikipedia_api import search as wiki_search, summary as wiki_summary
+from .groundnews_api import fetch_news, GroundNewsAPIError
+from .intent_metrics import calculate_idm, MetricInputs, timed_idm
+from .system_status import get_status, print_status
+
+__all__ = [
+    "activate_error_dignity",
+    "fetch_repo_files",
+    "fetch_languages",
+    "get_products",
+    "get_electricity_tariffs",
+    "wiki_search",
+    "wiki_summary",
+    "fetch_news",
+    "GroundNewsAPIError",
+    "calculate_idm",
+    "MetricInputs",
+    "timed_idm",
+    "get_status",
+    "print_status",
+]

tsal/utils/error_dignity.py

@@ -0,0 +1,20 @@
+"""Error dignity protocols."""
+
+from pathlib import Path
+
+ERROR_DIR = Path("errors")
+
+def activate_error_dignity(verbose: bool = False) -> None:
+    """Activate error dignity protocols.
+
+    Parameters
+    ----------
+    verbose : bool, optional
+        If True, print status messages. Defaults to False.
+    """
+    if verbose:
+        print("✺ Activating error dignity protocols...")
+        print("💥 → ✨ Transforming errors into gifts")
+    ERROR_DIR.mkdir(exist_ok=True)
+    if verbose:
+        print("🌀 Mad monkey learning: ENABLED")

tsal/utils/fuzzy_spellcheck.py

@@ -0,0 +1,7 @@
+from difflib import get_close_matches
+from typing import List
+
+def fuzzy_correct(token: str, op_list: List[str]) -> str:
+    """Suggest correction for code typos using ops from JSON schema."""
+    matches = get_close_matches(token, op_list, n=1, cutoff=0.7)
+    return matches[0] if matches else token

tsal/utils/github_api.py

@@ -0,0 +1,82 @@
+from typing import Dict, List, Optional
+
+try:  # optional dependency
+    import requests  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - fallback used in CI
+    import urllib.request
+
+    class _Response:
+        def __init__(self, text: str, status: int = 200) -> None:
+            self.text = text
+            self.status_code = status
+
+        def json(self) -> List[Dict]:
+            import json
+
+            return json.loads(self.text)
+
+        def raise_for_status(self) -> None:
+            if self.status_code >= 400:
+                raise RuntimeError(f"status {self.status_code}")
+
+    class requests:  # minimal shim for tests
+        @staticmethod
+        def get(url: str, headers: Dict[str, str] | None = None) -> _Response:
+            req = urllib.request.Request(url, headers=headers or {})
+            with urllib.request.urlopen(req) as resp:
+                text = resp.read().decode()
+            return _Response(text, resp.getcode())
+
+try:
+    import yaml
+except ModuleNotFoundError:  # pragma: no cover - simple parser
+    yaml = None
+
+def _get_json(url: str, headers: Dict[str, str]) -> List[Dict]:
+    resp = requests.get(url, headers=headers)
+    resp.raise_for_status()
+    return resp.json()
+
+def fetch_repo_files(
+    repo: str,
+    extensions: Optional[List[str]] = None,
+    token: Optional[str] = None,
+) -> Dict[str, str]:
+    """Fetch files from a GitHub repository via the GitHub API."""
+    base = f"https://api.github.com/repos/{repo}/contents"
+    headers = {}
+    if token:
+        headers["Authorization"] = f"token {token}"
+
+    def recurse(path: str) -> Dict[str, str]:
+        url = base + ("/" + path if path else "")
+        items = _get_json(url, headers)
+        files: Dict[str, str] = {}
+        for item in items:
+            if item["type"] == "file":
+                if extensions is None or any(
+                    item["name"].endswith(ext) for ext in extensions
+                ):
+                    f = requests.get(item["download_url"], headers=headers)
+                    if f.status_code == 200:
+                        files[item["path"]] = f.text
+            elif item["type"] == "dir":
+                files.update(recurse(item["path"]))
+        return files
+
+    return recurse("")
+
+def fetch_languages(
+    url: str = "https://raw.githubusercontent.com/github/linguist/master/lib/linguist/languages.yml",
+) -> List[str]:
+    """Return the list of programming languages from GitHub's Linguist database."""
+    resp = requests.get(url)
+    resp.raise_for_status()
+    if yaml:
+        data = yaml.safe_load(resp.text)
+        return list(data.keys())
+    langs = []
+    for line in resp.text.splitlines():
+        if ":" in line:
+            langs.append(line.split(":", 1)[0].strip())
+    return langs