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

tsal/tools/__init__.py

@@ -0,0 +1,43 @@
+from .codec import real_time_codec
+from .brian import SymbolicOptimizer, analyze_and_repair
+from .aletheia_checker import find_typos
+from .meshkeeper import scan, render_voxels
+from .watchdog import watch
+from .feedback_ingest import categorize, Feedback
+from .alignment_guard import is_aligned, Change
+from .goal_selector import Goal, score_goals
+from .spiral_audit import audit_path, audit_paths
+from .reflect import reflect
+from .kintsugi.kintsugi import kintsugi_repair
+from .module_draft import generate_template, draft_directory
+from .state_tracker import update_entry, show_entry
+from .archetype_fetcher import fetch_online_mesh, merge_mesh
+from .issue_agent import create_issue, handle_http_error
+
+__all__ = [
+    "real_time_codec",
+    "SymbolicOptimizer",
+    "analyze_and_repair",
+    "find_typos",
+    "scan",
+    "render_voxels",
+    "watch",
+    "categorize",
+    "Feedback",
+    "is_aligned",
+    "Change",
+    "Goal",
+    "score_goals",
+    "audit_path",
+    "audit_paths",
+    "reflect",
+    "kintsugi_repair",
+    "generate_template",
+    "draft_directory",
+    "update_entry",
+    "show_entry",
+    "fetch_online_mesh",
+    "merge_mesh",
+    "create_issue",
+    "handle_http_error",
+]

tsal/tools/aletheia_checker.py

@@ -0,0 +1,54 @@
+import difflib
+import re
+from pathlib import Path
+
+TARGET = "aletheia"
+# Known common misspellings that should be flagged immediately
+COMMON_TYPOS = {
+    "athalaya",  # seen in various docs
+    "athaleia",
+    "alethei",  # truncated
+}
+
+def is_typo(word: str) -> bool:
+    lw = word.lower()
+    if lw == TARGET:
+        return False
+    if lw in COMMON_TYPOS:
+        return True
+    ratio = difflib.SequenceMatcher(None, lw, TARGET).ratio()
+    return ratio >= 0.7
+
+def scan_file(path: Path) -> list[tuple[int, str]]:
+    results = []
+    pattern = re.compile(r"[A-Za-z_-]+")
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        for lineno, line in enumerate(f, 1):
+            for word in pattern.findall(line):
+                if is_typo(word):
+                    results.append((lineno, line.rstrip()))
+                    break
+    return results
+
+def find_typos(root: Path) -> dict[str, list[tuple[int, str]]]:
+    typos = {}
+    for path in root.rglob("*"):
+        if path.is_file() and path.suffix.lower() in {
+            ".py",
+            ".md",
+            ".txt",
+            ".json",
+            ".yaml",
+            ".yml",
+        }:
+            found = scan_file(path)
+            if found:
+                typos[str(path)] = found
+    return typos
+
+if __name__ == "__main__":
+    repo_root = Path(__file__).resolve().parents[3]
+    hits = find_typos(repo_root)
+    for filepath, items in hits.items():
+        for lineno, line in items:
+            print(f"{filepath}:{lineno}: {line}")

tsal/tools/alignment_guard.py

@@ -0,0 +1,20 @@
+"""Verify spiral alignment of proposed changes."""
+
+from dataclasses import dataclass
+
+from tsal.core.spiral_vector import phi_alignment
+
+@dataclass
+class Change:
+    description: str
+    complexity: float
+    coherence: float
+
+def is_aligned(change: Change, threshold: float = 0.76) -> bool:
+    """Return True if change clears φ score and keyword filter."""
+    score = phi_alignment(change.complexity, change.coherence)
+    if score < threshold:
+        return False
+    banned = {"coerce", "exploit"}
+    lowered = change.description.lower()
+    return not any(word in lowered for word in banned)

tsal/tools/archetype_fetcher.py

@@ -0,0 +1,44 @@
+import json
+from pathlib import Path
+from typing import List, Dict
+
+try:
+    import requests
+except ModuleNotFoundError:  # pragma: no cover - fallback
+    import urllib.request as _u
+
+    class _Resp:
+        def __init__(self, text: str, status: int = 200) -> None:
+            self.text = text
+            self.status_code = status
+
+        def raise_for_status(self) -> None:
+            if self.status_code >= 400:
+                raise RuntimeError(f"status {self.status_code}")
+
+    class requests:
+        @staticmethod
+        def get(url: str) -> _Resp:
+            with _u.urlopen(url) as f:
+                return _Resp(f.read().decode(), f.getcode())
+
+
+def fetch_online_mesh(url: str) -> List[Dict]:
+    """Fetch archetype mesh entries from ``url``."""
+    resp = requests.get(url)
+    resp.raise_for_status()
+    return json.loads(resp.text)
+
+
+def merge_mesh(mesh_path: Path, entries: List[Dict]) -> None:
+    """Merge ``entries`` into JSON mesh at ``mesh_path`` by archetype name."""
+    if mesh_path.exists():
+        data = json.loads(mesh_path.read_text())
+    else:
+        data = []
+    names = {e.get("name") for e in data}
+    for e in entries:
+        if e.get("name") not in names:
+            data.append(e)
+            names.add(e.get("name"))
+    mesh_path.write_text(json.dumps(data, indent=2))

tsal/tools/brian/__init__.py

@@ -0,0 +1,5 @@
+"""Brian Spiral Code Healer tools."""
+
+from .optimizer import SymbolicOptimizer, analyze_and_repair, spiral_optimize
+
+__all__ = ["SymbolicOptimizer", "analyze_and_repair", "spiral_optimize"]

tsal/tools/brian/optimizer.py

@@ -0,0 +1,205 @@
+"""Symbolic diff, repair, and spiral resequencer engine."""
+
+import ast
+from pathlib import Path
+from typing import List, Dict, Optional, Tuple
+
+from tsal.core.rev_eng import Rev_Eng
+from tsal.core.phase_math import phase_match_enhanced
+from tsal.core.optimizer_utils import (
+    SymbolicSignature,
+    extract_signature,
+)
+from tsal.core.spiral_vector import SpiralVector, phi_alignment
+
+class SymbolicOptimizer:
+    """Walks Python AST, computes signatures, and suggests repairs."""
+
+    def __init__(
+        self,
+        target_signatures: Optional[Dict[str, List[float]]] = None,
+        rev_eng: Optional[Rev_Eng] = None,
+    ):
+        self.target_signatures = target_signatures or {}
+        self.rev = rev_eng or Rev_Eng(origin="SymbolicOptimizer")
+
+    def analyze(self, code: str) -> List[Tuple[SymbolicSignature, Dict]]:
+        try:
+            tree = ast.parse(code)
+        except SyntaxError:
+            self.rev.log_event("ANTISPIRAL", file="<buffer>")
+            raise
+        results = []
+        for node in ast.walk(tree):
+            if isinstance(
+                node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+            ):
+                sig = extract_signature(node, node.name)
+                target_vec = self.target_signatures.get(sig.name, sig.vector)
+                local_state = sig.magnitude()
+                target_state = sum(target_vec)
+                aligned_state, energy, metrics = phase_match_enhanced(
+                    local_state, target_state
+                )
+                delta = metrics.get("delta", 0)
+                self.rev.log_event(
+                    "ANALYZE", name=sig.name, delta=delta, energy=energy
+                )
+                results.append((sig, metrics))
+        return results
+
+    def suggest_order(self, signatures: List[SymbolicSignature]) -> List[str]:
+        scored = []
+        for sig in signatures:
+            target_vec = self.target_signatures.get(sig.name, sig.vector)
+            local_state = sig.magnitude()
+            target_state = sum(target_vec)
+            _, energy, _ = phase_match_enhanced(local_state, target_state)
+            scored.append((sig.name, energy))
+        scored.sort(key=lambda x: x[1])
+        return [name for name, _ in scored]
+
+    def annotate_code(self, code: str) -> str:
+        tree = ast.parse(code)
+        signatures = []
+        for node in ast.walk(tree):
+            if isinstance(
+                node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+            ):
+                sig = extract_signature(node, node.name)
+                signatures.append(sig)
+                target_vec = self.target_signatures.get(sig.name, sig.vector)
+                local_state = sig.magnitude()
+                target_state = sum(target_vec)
+                _, energy, metrics = phase_match_enhanced(
+                    local_state, target_state
+                )
+                comment = ast.Expr(
+                    value=ast.Constant(
+                        value=f"OPTENERGY {energy:.3f} Δ{metrics['delta']:.3f}"
+                    )
+                )
+                node.body.insert(0, comment)
+        annotated = ast.unparse(tree)
+        ordered_names = self.suggest_order(signatures)
+        header = f"# Suggested order: {', '.join(ordered_names)}\n"
+        return header + annotated
+
+    def repair_file(self, file_path: str) -> List[str]:
+        """Rewrites the file when reordering is required and returns suggestions.
+
+        The function analyzes the order of functions and classes in ``file_path``.
+        If the current ordering differs from the ideal, the file is rewritten with
+        the reordered definitions. A list of string suggestions describing the
+        deltas is returned regardless of whether rewriting occurred.
+        """
+        code = Path(file_path).read_text()
+        try:
+            tree = ast.parse(code)
+        except SyntaxError:
+            self.rev.log_event("ANTISPIRAL", file=file_path)
+            raise
+        items = []
+        for node in tree.body:
+            if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
+                items.append(node.name)
+        ideal = self.suggest_order(
+            [
+                extract_signature(node, node.name)
+                for node in tree.body
+                if isinstance(node, (ast.FunctionDef, ast.ClassDef))
+            ]
+        )
+        suggestions = []
+        for idx, name in enumerate(items):
+            ideal_idx = ideal.index(name)
+            delta = idx - ideal_idx
+            _, energy, metrics = phase_match_enhanced(
+                float(idx), float(ideal_idx)
+            )
+            suggestion = f"{name}: Δ={delta} energy={energy:.3f} φ={metrics['phase_signature']}"
+            suggestions.append(suggestion)
+        if items != ideal:
+            new_body = []
+            name_map = {
+                node.name: node
+                for node in tree.body
+                if isinstance(node, (ast.FunctionDef, ast.ClassDef))
+            }
+            for name in ideal:
+                new_body.append(name_map[name])
+            for node in tree.body:
+                if not isinstance(node, (ast.FunctionDef, ast.ClassDef)):
+                    new_body.append(node)
+            tree.body = new_body
+            Path(file_path).write_text(ast.unparse(tree))
+        return suggestions
+
+from typing import Union
+
+def analyze_and_repair(
+    file_path: Union[str, Path], repair: bool = False
+) -> list:
+    """Analyze or repair ``file_path``. Directories are processed recursively."""
+    path = Path(file_path)
+    if path.is_dir():
+        results = []
+        for file in path.rglob("*.py"):
+            results.extend(analyze_and_repair(file, repair=repair))
+        return results
+
+    opt = SymbolicOptimizer()
+    if repair:
+        try:
+            return opt.repair_file(str(path))
+        except SyntaxError:
+            return [f"ANTISPIRAL {path}"]
+
+    try:
+        code = path.read_text()
+    except IsADirectoryError:
+        return []
+
+    try:
+        results = opt.analyze(code)
+    except SyntaxError:
+        return [f"ANTISPIRAL {path}"]
+    return [
+        f"{sig.name}: energy={metrics['energy_required']:.3f} Δ={metrics.get('delta',0)}"
+        for (sig, metrics) in results
+    ]
+
+def spiral_optimize(functions: List[SpiralVector]) -> List[SpiralVector]:
+    """Return ``functions`` sorted by φ-alignment score."""
+
+    return sorted(
+        functions,
+        key=lambda v: phi_alignment(v.complexity, v.coherence),
+        reverse=True,
+    )
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Brian spiral optimizer")
+    parser.add_argument("path", help="Python file to analyze")
+    parser.add_argument(
+        "--repair", action="store_true", help="Rewrite file in spiral order"
+    )
+    args = parser.parse_args()
+
+    opt = SymbolicOptimizer()
+    if args.repair:
+        res = opt.repair_file(args.path)
+    else:
+        code = Path(args.path).read_text()
+        results = opt.analyze(code)
+        res = [
+            f"{sig.name}: energy={metrics['energy_required']:.3f} Δ={metrics.get('delta',0)}"
+            for (sig, metrics) in results
+        ]
+    for line in res:
+        print(line)
+
+if __name__ == "__main__":
+    main()

tsal/tools/codec.py

@@ -0,0 +1,31 @@
+"""Real-time decode/encode helper."""
+
+from typing import Iterable, Callable, Optional
+from importlib import resources
+
+from tsal.core.json_dsl import LanguageMap, SymbolicProcessor
+from tsal.core.rev_eng import Rev_Eng
+
+def real_time_codec(
+    lines: Iterable[str],
+    schema: str | None = None,
+    transform: Optional[Callable[[list[dict]], list[dict]]] = None,
+    rev: Optional[Rev_Eng] = None,
+) -> str:
+    """Decode lines, run an optional token transform, encode result.
+
+    ``lines`` is any iterable yielding code lines. If ``schema`` is not
+    provided, the built-in Python schema is used. ``transform`` receives the
+    token list before encoding. ``rev`` logs byte counts for in/out data.
+    """
+    if schema is None:
+        schema = str(resources.files("tsal.schemas").joinpath("python.json"))
+    lang = LanguageMap.load(schema)
+    rev = rev or Rev_Eng(origin="real_time_codec")
+    sp = SymbolicProcessor(lang, rev_eng=rev)
+
+    source = list(lines)
+    tokens = sp.decode(source)
+    if transform:
+        tokens = transform(tokens)
+    return sp.encode(tokens)

tsal/tools/feedback_ingest.py

@@ -0,0 +1,25 @@
+"""Feedback ingestion and scoring for Rev_Eng logs."""
+# TODO: expand scoring rules (experimental)
+
+from dataclasses import dataclass
+from typing import Iterable, List
+
+from tsal.core.spiral_vector import phi_alignment
+
+@dataclass
+class Feedback:
+    source: str
+    content: str
+    score: float = 0.0
+
+def _score(line: str) -> float:
+    complexity = float(len(line)) * 0.1
+    lowered = line.lower()
+    coherence = 1.0
+    if "error" in lowered or "bad" in lowered:
+        coherence = 0.1
+    return phi_alignment(complexity, coherence)
+
+def categorize(feedback: Iterable[str]) -> List[Feedback]:
+    """Return feedback objects with φ-resonance scores."""
+    return [Feedback("user", line, _score(line)) for line in feedback]

tsal/tools/goal_selector.py

@@ -0,0 +1,26 @@
+"""Score goals for priority based on mesh and alignment."""  # [!INTERNAL STUB]
+# TODO: refine scoring with RL signals (experimental)
+
+from dataclasses import dataclass
+from typing import Iterable, List
+
+@dataclass
+class Goal:
+    name: str
+    mesh_benefit: float
+    alignment: float
+    cost: float
+    novelty: float
+
+def score_goals(goals: Iterable[Goal]) -> List[Goal]:
+    """Return goals ordered by priority."""
+    return sorted(
+        goals,
+        key=lambda g: (
+            g.mesh_benefit * g.alignment
+            + 0.1 * g.mesh_benefit
+            - g.cost
+            + g.novelty
+        ),
+        reverse=True,
+    )

tsal/tools/issue_agent.py

@@ -0,0 +1,67 @@
+"""Autonomous issue creator for mesh agents."""
+
+from __future__ import annotations
+
+import json as _json
+from typing import Dict, Optional
+
+try:  # optional dependency
+    import requests  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - fallback used in CI
+    import urllib.request
+
+    class _Resp:
+        def __init__(self, text: str, status: int = 200) -> None:
+            self.text = text
+            self.status_code = status
+
+        def json(self) -> Dict:
+            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:
+        @staticmethod
+        def post(url: str, json: Dict, headers: Optional[Dict[str, str]] = None) -> _Resp:
+            data = _json.dumps(json or {}).encode()
+            req = urllib.request.Request(url, data=data, headers=headers or {}, method="POST")
+            with urllib.request.urlopen(req) as resp:
+                text = resp.read().decode()
+            return _Resp(text, resp.getcode())
+
+
+def create_issue(repo: str, title: str, body: str, token: str) -> int:
+    """Open an issue on ``repo`` and return the issue number."""
+    url = f"https://api.github.com/repos/{repo}/issues"
+    headers = {
+        "Authorization": f"token {token}",
+        "Accept": "application/vnd.github+json",
+    }
+    payload = {"title": title, "body": body}
+    resp = requests.post(url, json=payload, headers=headers)
+    resp.raise_for_status()
+    data = resp.json()
+    return int(data.get("number", 0))
+
+
+def sandbox_diagnostics(log: str) -> None:
+    """Placeholder diagnostics when auth fails."""
+    print("🐒 Mad monkey diagnostics engaged")
+    print(log)
+
+
+def handle_http_error(repo: str, err: Exception, log: str, token: Optional[str] = None) -> None:
+    """Create a GitHub issue for auth errors and trigger diagnostics."""
+    msg = str(err)
+    if "403" in msg or "404" in msg:
+        if token:
+            body = f"Error: {msg}\n\nLogs:\n```\n{log}\n```\nCheck PAT permissions."
+            try:
+                create_issue(repo, "Auth failure detected", body, token)
+            except Exception as ex:  # pragma: no cover - network faults
+                sandbox_diagnostics(f"Issue creation failed: {ex}\n{log}")
+        else:
+            sandbox_diagnostics(log)
+

tsal/tools/kintsugi/__init__.py

@@ -0,0 +1 @@
+from .kintsugi import kintsugi_repair

tsal/tools/kintsugi/kintsugi.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+from tsal.tools.brian.optimizer import analyze_and_repair
+
+def kintsugi_repair(file_path: str) -> list[str]:
+    """Run repair, and label damage as unique evolution."""
+    try:
+        output = analyze_and_repair(file_path, repair=True)
+        if output:
+            return [f"✨ [r]evolution vector: {line}" for line in output]
+        return ["✅ Already coherent."]
+    except Exception as e:
+        return [
+            f"💀 Damage recognized: {e}",
+            "⚡ Marking as potential Kintsugi Vector.",
+        ]

tsal/tools/meshkeeper.py

@@ -0,0 +1,81 @@
+"""Minimal mesh log scanner and voxel viewer."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import List, Dict, Any
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+def scan(log_path: str) -> List[Dict[str, Any]]:
+    """Return list of DATA payloads from a mesh log file."""
+    entries: List[Dict[str, Any]] = []
+    path = Path(log_path)
+    if not path.exists():
+        return entries
+    for line in path.read_text().splitlines():
+        try:
+            obj = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if obj.get("event_type") == "DATA" and isinstance(
+            obj.get("payload"), dict
+        ):
+            entries.append(obj["payload"])
+    return entries
+
+def render_voxels(voxels: List[Dict[str, Any]]) -> None:
+    """Render voxels using matplotlib."""
+    if not voxels:
+        return
+    xs = np.array([v.get("pace", 0) for v in voxels])
+    ys = np.array([v.get("rate", 0) for v in voxels])
+    zs = np.arange(len(voxels))
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection="3d")
+    ax.scatter(xs, ys, zs)
+    ax.set_xlabel("pace")
+    ax.set_ylabel("rate")
+    ax.set_zlabel("index")
+    plt.show()
+
+def summarize(voxels: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Return simple stats from the voxel list."""
+    if not voxels:
+        return {"voxels": 0}
+    pace = np.array([v.get("pace", 0.0) for v in voxels], dtype=float)
+    rate = np.array([v.get("rate", 0.0) for v in voxels], dtype=float)
+    return {
+        "voxels": len(voxels),
+        "pace": {
+            "min": float(pace.min()),
+            "max": float(pace.max()),
+            "avg": float(pace.mean()),
+        },
+        "rate": {
+            "min": float(rate.min()),
+            "max": float(rate.max()),
+            "avg": float(rate.mean()),
+        },
+    }
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="TSAL Meshkeeper")
+    parser.add_argument("log", nargs="?", default="data/mesh_log.jsonl")
+    parser.add_argument("--render", action="store_true")
+    parser.add_argument("--dump", metavar="PATH", help="write raw voxels to file")
+    args = parser.parse_args()
+    voxels = scan(args.log)
+    if args.dump:
+        Path(args.dump).write_text(json.dumps(voxels))
+        return
+    if args.render:
+        render_voxels(voxels)
+    else:
+        print(json.dumps(summarize(voxels)))
+
+if __name__ == "__main__":
+    main()

tsal/tools/module_draft.py

@@ -0,0 +1,54 @@
+import ast
+from pathlib import Path
+from typing import List
+# TODO: rewrite using AST pattern matching (experimental)
+
+
+def generate_template(file_path: str) -> str:
+    """Return a stripped template of ``file_path`` preserving public interface."""
+    path = Path(file_path)
+    tree = ast.parse(path.read_text())
+
+    new_body: List[ast.stmt] = []
+    body = list(tree.body)
+
+    if body and isinstance(body[0], ast.Expr) and isinstance(body[0].value, ast.Constant) and isinstance(body[0].value.value, str):
+        new_body.append(body.pop(0))
+
+    for node in body:
+        if isinstance(node, (ast.Import, ast.ImportFrom)):
+            new_body.append(node)
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            node.body = [ast.Pass()]
+            new_body.append(node)
+
+    tree.body = new_body
+    return ast.unparse(tree)
+
+
+def draft_directory(base: Path, dest: Path) -> List[Path]:
+    """Generate templates for ``base`` under ``dest`` directory."""
+    generated = []
+    for file in base.rglob("*.py"):
+        template = generate_template(str(file))
+        target = dest / file.relative_to(base)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(template)
+        generated.append(target)
+    return generated
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate interface templates")
+    parser.add_argument("base", nargs="?", default="src/tsal")
+    parser.add_argument("--dest", default="drafts")
+    args = parser.parse_args()
+
+    paths = draft_directory(Path(args.base), Path(args.dest))
+    print(f"Generated {len(paths)} templates under {args.dest}")
+
+
+if __name__ == "__main__":
+    main()