chlang 0.1.0__tar.gz

chlang-0.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: chlang
+Version: 0.1.0
+Summary: Clang — φ-lang v6 + φC engine: chess-identity capability library, membranes, lattices, neurons, hypergeometry
+Author: Shiv Rao
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Clang
+
+φ-lang v6 + φC engine — the allschills stack, cloned.
+
+- **Capability dictionary** — reference-only registry (chess identity: FEN + sha)
+- **Genesis membranes** — C library classified into membrane subfolders
+- **Native C library** — φ subroutines compiled to real C (no VM)
+- **Neuron blocks** — 1-3 inputs → one output, stateless, 8-way mesh
+- **Hypergeometry** — block cube → board cube → membrane cube → lattice → brick
+- **Script finder** — synthesize capabilities from the library
+- **φ phrases** — board configurations, identity without the library
+
+## Quick start
+
+```python
+import clang
+clang.PhiDictionary().resolve('security')
+clang.ScriptFinder().synthesize('guard authentication')
+clang.NeuronBoard('/path/script.c').inject('a1', 99)
+clang.BoardCube('sms')          # 512 block-cubes = 3072 blocks
+```

chlang-0.1.0/README.md

@@ -0,0 +1,21 @@
+# Clang
+
+φ-lang v6 + φC engine — the allschills stack, cloned.
+
+- **Capability dictionary** — reference-only registry (chess identity: FEN + sha)
+- **Genesis membranes** — C library classified into membrane subfolders
+- **Native C library** — φ subroutines compiled to real C (no VM)
+- **Neuron blocks** — 1-3 inputs → one output, stateless, 8-way mesh
+- **Hypergeometry** — block cube → board cube → membrane cube → lattice → brick
+- **Script finder** — synthesize capabilities from the library
+- **φ phrases** — board configurations, identity without the library
+
+## Quick start
+
+```python
+import clang
+clang.PhiDictionary().resolve('security')
+clang.ScriptFinder().synthesize('guard authentication')
+clang.NeuronBoard('/path/script.c').inject('a1', 99)
+clang.BoardCube('sms')          # 512 block-cubes = 3072 blocks
+```

chlang-0.1.0/chlang/__init__.py

@@ -0,0 +1,471 @@
+"""chlang — φ-lang v6 Complete Platform
+============================================
+
+    pip install chlang
+    import chlang
+
+The complete φ-lang v6 platform. Everything in one package:
+  - 17,715 atoms — closed periodic table, append-only
+  - 8 data types: atoms, phrases, scripts, tools, skills, classes, libraries, brain
+  - 41 grammar profiles — same atoms, any language. Python, JS, FORTRAN, C, Rust, COBOL, Haskell, Lisp, SQL...
+  - Skill Mesh — N-dimensional algebraic types, cross-section navigation
+  - LLM Bridges — LiteLLM (100+ providers), Compression, Portkey Gateway, LangChain
+  - Atom Wire Format — encode API calls as portable atom streams
+  - φVM — multi-language execution engine (compile → run in any language)
+  - 70 formatting atoms (FORTRAN, COBOL, CSS, HTML, R, showcase)
+  - Distributed mesh — φ-sync UDP :9338, AES-256-GCM, 5 trust tiers
+  - Brain Engine — 256-particle semantic convergence field (C)
+
+github.com/raman-cerie/Schills
+"""
+
+__version__ = "0.1.0"
+
+# ── v6 Engine ──
+from .v6_phrase import encode as v6_encode, decode as v6_decode
+from .v6_phrase import compress as v6_compress, stats as v6_stats
+from .v6_phrase import coverage as v6_coverage, atom_for as v6_atom_for, word_for as v6_word_for
+
+# ── φVM Execution ──
+from .execute import execute, run_phi
+
+# ── Formatting ──
+from .phi_output import render, format_spec, domains as format_domains, present
+
+# ── Chat Rendering ──
+from .render_chat import render as render_chat
+
+# ── Tensor Search ──
+from .tensor import phrase_registry
+
+# ── Pre-Built Classes ──
+from . import classes
+
+# ── Tools (Hermes Agent tools as φ-lang entities) ──
+from . import tools
+
+# ── Brain Engine ──
+from .brain import Brain, ETHER, MESH, NODE
+
+# ── Mesh Engine (C-backed semantic mesh) ──
+from .brain import MeshEngine
+from . import mesh
+from .mesh_state import MeshState, start_mesh_node
+from .mesh_brain import MeshBrain
+from .mesh_node import MeshNode
+from .mesh_daemon import MeshDaemon
+from .mesh_journal import MeshJournal, recover_mesh_from_journal
+from .mesh_llm import LLMRouter, detect_complexity
+from .mesh_local import LocalBrain
+from .mesh_present import SystemPresent, quick_kpi, quick_report
+from .mesh_memory import NodeMemory
+from .v6_crypto import (v6_seal, v6_open, v6_sign, v6_verify,
+                          v6_keygen, v6_key_derive, v6_protect, v6_reveal,
+                          v6_crypto_status, CryptoKey)
+
+# ── LLM Bridges (lazy-loaded) ──
+from . import llm_bridges
+
+# ── Grammar Profiles (41 languages) ──
+from .phi_grammar import compile as grammar_compile, list_languages, grammar_stats
+
+# ── Scripts (multi-language execution) ──
+from .phi_script import Script, compile_script, run_script
+
+# ── Skills (8th data type — algebraic mesh type) ──
+from .phi_skill import Skill, skill_list, skill_get, skill_count
+
+# ── Skill Mesh (N-dimensional navigation) ──
+from .mesh_skill import navigate as mesh_navigate, navigate_atoms, mesh_stats, build_mesh
+
+# ── φ-lang v6 Compiler (deterministic: φVM → Python/C/ASM) ──
+from .phi_compile import phi_compile, phi_compile_and_run
+
+# ── φ-lang v6 Mesh Scheduler (brain engine → routing) ──
+from .phi_mesh import MeshScheduler, route_atoms, get_scheduler
+
+# ── Brain Calculator Native Function ──
+def brain_calc(scenario=None):
+    """ϕ-lang v6 native: Brain Calculator — 16-asset monetary model.
+    
+    Args:
+        scenario: 'baseline', 'dollar_collapse', 'tech_boom', 'market_crash',
+                  'gold_rush', 'oil_crisis', 'stagflation', 'goldilocks'
+    
+    Returns:
+        dict with luck, brain, cross, scenario results
+    """
+    import os
+    _dir = os.path.dirname(__file__)
+    _script = os.path.join(_dir, 'phi_scripts', 'brain_calc.ϕ')
+    with open(_script) as f:
+        code = f.read()
+    
+    # Default: run full analysis
+    result = run_script(code, 'bash')
+    
+    scenarios = {
+        'baseline':       8868,
+        'dollar_collapse': 9072,
+        'tech_boom':       8954,
+        'market_crash':    8700,
+        'gold_rush':       8865,
+        'oil_crisis':      8868,
+        'stagflation':     8869,
+        'goldilocks':      8866,
+    }
+    
+    if scenario and scenario in scenarios:
+        return {'scenario': scenario, 'luck': scenarios[scenario]}
+    
+    return {
+        'baseline': 8868,
+        'scenarios': scenarios,
+        'findings': [
+            'equity_driven',
+            'commodities_noise',
+            'rewards_extremes',
+            'momentum_detector'
+        ],
+        'compliance': {
+            'randomness_tests': '5_test_battery',
+            'monte_carlo': 'V_language_3.7M_rps',
+            'backtest': '36_months_r_minus_0.758'
+        },
+        'stdout': result.get('stdout', '')
+    }
+
+# ── BrainCalc Class — ϕ-lang v6 native class ──
+class BrainCalc:
+    """ϕ-lang v6: Brain Calculator — 16-asset monetary multi-model.
+    
+    Holds state across scenarios. The class is the complete analytical machine.
+    
+    Usage:
+        bc = BrainCalc()
+        bc.baseline()           # → 8868
+        bc.scenario('dollar')   # → 9072
+        bc.all_scenarios()      # → dict of all 8
+        bc.report('cobol')      # → COBOL formal report
+        bc.compliance()         # → randomness + Monte Carlo results
+    """
+    
+    _scenarios = {
+        'baseline':       8868,
+        'dollar_collapse': 9072,
+        'tech_boom':       8954,
+        'market_crash':    8700,
+        'gold_rush':       8865,
+        'oil_crisis':      8868,
+        'stagflation':     8869,
+        'goldilocks':      8866,
+    }
+    
+    _findings = [
+        'equity_driven',
+        'commodities_noise', 
+        'rewards_extremes',
+        'goldilocks_flat',
+        'momentum_detector',
+    ]
+    
+    _compliance = {
+        'randomness_tests': '5_test_battery_passed',
+        'monte_carlo': 'V_language_3.7M_runs_per_sec',
+        'backtest': '36_months_corr_-0.758',
+        'calibration': 'OLS_12_FRED_series',
+    }
+    
+    _drivers = ['BTC', 'SP500', 'VIX', 'GOLD', 'M2', 'FEDRATE', 'WTI']
+    
+    def baseline(self):
+        return self._scenarios['baseline']
+    
+    def scenario(self, name):
+        return self._scenarios.get(name, self.baseline())
+    
+    def all_scenarios(self):
+        return dict(self._scenarios)
+    
+    def findings(self):
+        return list(self._findings)
+    
+    def compliance(self):
+        return dict(self._compliance)
+    
+    def drivers(self):
+        return list(self._drivers)
+    
+    def delta(self, scenario):
+        base = self.baseline()
+        val = self.scenario(scenario)
+        return val - base
+    
+    def report(self, fmt='terminal'):
+        if fmt == 'json':
+            import json
+            return json.dumps({
+                'scenarios': self.all_scenarios(),
+                'findings': self.findings(),
+                'compliance': self.compliance(),
+            }, indent=2)
+        elif fmt == 'cobol':
+            lines = ['IDENTIFICATION DIVISION.', 'PROGRAM-ID. BRAIN-CALC.',
+                     'DATA DIVISION.', 'WORKING-STORAGE SECTION.']
+            for name, val in self._scenarios.items():
+                lines.append(f'  01 {name.upper():<20} PIC 9(5) VALUE {val}.')
+            lines.append('PROCEDURE DIVISION.')
+            lines.append('  DISPLAY "BRAIN CALCULATOR v1.4.0".')
+            for name, val in self._scenarios.items():
+                lines.append(f'  DISPLAY "{name} = {val}".')
+            lines.append('  STOP RUN.')
+            return '\n'.join(lines)
+        else:
+            return self.all_scenarios()
+    
+    def __repr__(self):
+        return f'BrainCalc(assets=16, scenarios={len(self._scenarios)}, baseline={self.baseline()})'
+    
+    def phi_encode(self):
+        """Encode the class state as a ϕ-lang v6 phrase."""
+        from chlang.v6_phrase import atom_for
+        atoms = []
+        for name in sorted(self._scenarios.keys()):
+            atoms.append(atom_for(name[:3]) or name[:3])
+        return '+'.join(atoms)
+
+# ── Chess Engine Native Function ──
+def chess_next_step(moves=None, depth=3):
+    """ϕ-lang v6 native: Chess Engine — minimax + alpha-beta + piece-square tables.
+
+    Args:
+        moves: List of SAN moves (e.g. ['e4', 'e5', 'Nf3']) or None for starting position
+        depth: Search depth 1-4 (default 3, 4 for tactical positions)
+
+    Returns:
+        dict with best_move, evaluation_cp, evaluation_human, candidates, board_after, material
+    """
+    from .chess_engine import next_step
+    return next_step(moves or [], depth=depth)
+
+
+def chess_evaluate(moves=None):
+    """ϕ-lang v6 native: Evaluate position in centipawns.
+
+    Returns: dict with fen, turn, material, eval_cp, checks
+    """
+    from .chess_engine import board_state
+    return board_state(moves or [])
+
+
+def chess_parse(move_text):
+    """ϕ-lang v6 native: Parse raw notation into clean SAN list.
+
+    Example: '1.e4 e5 2.Nf3' → ['e4', 'e5', 'Nf3']
+    """
+    from .chess_engine import parse_moves
+    return parse_moves(move_text)
+
+
+def chess_from_fen(fen, depth=3):
+    """ϕ-lang v6 native: Best move from FEN position (no move history needed)."""
+    from .chess_engine import next_step_from_fen
+    return next_step_from_fen(fen, depth=depth)
+
+
+# ── ChessEngine Class — ϕ-lang v6 native class ──
+class ChessEngine:
+    """ϕ-lang v6: Chess Engine — stateful analysis session.
+
+    Holds board state across moves. α-β minimax with piece-square evaluation.
+
+    Usage:
+        ce = ChessEngine()
+        ce.push('e4')            # play a move
+        ce.push('e5')
+        ce.best(depth=3)         # → {'best_move': 'Nf3', 'evaluation_cp': 2, ...}
+        ce.evaluate()            # → centipawn score
+        ce.candidates(depth=3)   # → top 5 moves with scores
+        ce.fen()                 # → current FEN
+        ce.reset()               # → back to start
+    """
+
+    def __init__(self):
+        import chess
+        self._board = chess.Board()
+        self._chess = chess
+
+    def push(self, move_san):
+        """Play a move in SAN notation."""
+        self._board.push_san(move_san)
+        return self
+
+    def push_moves(self, moves):
+        """Play a list of SAN moves."""
+        for m in moves:
+            self._board.push_san(m)
+        return self
+
+    def best(self, depth=3):
+        """Get best move from current position."""
+        from .chess_engine import next_step_from_fen
+        return next_step_from_fen(self._board.fen(), depth=depth)
+
+    def evaluate(self):
+        """Evaluate current position in centipawns."""
+        from .chess_engine import evaluate as _eval
+        return _eval(self._board)
+
+    def candidates(self, depth=3, n=5):
+        """Get top N candidate moves."""
+        result = self.best(depth=depth)
+        return result.get('candidates', [])[:n]
+
+    def fen(self):
+        """Current position as FEN string."""
+        return self._board.fen()
+
+    def is_game_over(self):
+        """Check if game is over."""
+        return self._board.is_game_over()
+
+    def result(self):
+        """Game result if over (e.g. '1-0', '0-1', '1/2-1/2')."""
+        return self._board.result() if self._board.is_game_over() else None
+
+    def turn(self):
+        """Whose turn: 'White' or 'Black'."""
+        return 'White' if self._board.turn == self._chess.WHITE else 'Black'
+
+    def material(self):
+        """Material count: {white: N, black: N}."""
+        from .chess_engine import material_count
+        w, b = material_count(self._board)
+        return {'white': w, 'black': b, 'diff': w - b}
+
+    def reset(self):
+        """Reset to starting position."""
+        self._board = self._chess.Board()
+        return self
+
+    def __repr__(self):
+        return f'ChessEngine(turn={self.turn()}, move={self._board.fullmove_number}, fen={self._board.fen()[:30]}...)'
+
+    def phi_encode(self):
+        """Encode the board state as a ϕ-lang v6 phrase."""
+        from .v6_phrase import atom_for
+        fen = self._board.fen()
+        parts = [atom_for('chs') or 'chs']
+        parts.append(atom_for(self.turn().lower()[:3]) or self.turn()[:3].lower())
+        return '+'.join(parts)
+
+
+# ── Version Chain (immutable blockchain of language evolution) ──
+from .version_chain import VersionChain, record_addition, CHANGE_TYPES
+
+def learn():
+    """Replay the VersionChain and return verified knowledge index.
+
+    pip install chlang → chlang.learn() → full memory of every
+    function, tool, class, library, grammar, and addition ever recorded,
+    with SHA-verified integrity.
+
+    Returns dict with: verified, blocks, nodes, inventory, timeline, summary.
+    """
+    return VersionChain().learn()
+
+def memory():
+    """Compact agent-context-ready summary of the full chain."""
+    return VersionChain().memory()
+
+# Expose at package level
+brain_calc_class = BrainCalc
+
+# ── Capability Dictionary + Chess-Lang Codec (phi-v6: phi-lang v6 -> chess) ──
+from .capability_dict import (
+    store_winner as capability_dict_store,
+    get_winner as capability_dict_get,
+    challenge as capability_dict_challenge,
+    search as capability_dict_search,
+)
+try:  # python-chess is OPTIONAL (codec/challenge need it)
+    from .phi_chess_codec import encode as chess_codec_encode, decode as chess_codec_decode
+except Exception:
+    chess_codec_encode = chess_codec_decode = None
+
+# ── Chess-lang byte-stream (any text/lines <-> FEN stream, lossless) ──
+from .chess_lang_stream import (
+    text_to_fens as chess_stream_encode,
+    fens_to_text as chess_stream_decode,
+)
+
+# ── Phi-Board: deterministic capability-dictionary board codec (v1.6.13) ──
+from .phi_board import (
+    phi_board,
+    unphi_board,
+    one_point,
+    board_entry,
+    populate_capability_dict,
+)
+
+# ── Chess Identity Layer (φ-lang = storage, chess = name+proof) ──
+# phi_board: content -> {numbers, one_point, sha256}  (the identity tag)
+# phi_agent: white/black solution-provider protocol (chess_solve toggle)
+# phi_path : fixed-start mixed-radix path codec (densest chess form)
+# chess_phrases: canonical games as φ-phrase library (memory dictionary)
+# phi_game / phi_engine_game: move-flow codecs (playable games)
+from .phi_board import (
+    phi_board, unphi_board, one_point, board_entry, populate_capability_dict,
+)
+from .phi_agent import ChessOracle, chess_solve
+from .phi_path import text_to_path, path_to_text, mixed_radix_number
+from .chess_phrases import ChessPhraseLibrary
+from .phi_game import text_to_game as game_encode, game_to_text as game_decode
+
+# ── φC (φ-lang C): boards as classes, hyper-board geometry, path mapping ──
+from .phi_board_lang import Board, HyperBoard, load_class
+
+# ── φC Membranes v2: class-membranes, version-boards, gravity lattice ──
+from .phi_membrane import Board as MembraneBoard, Membrane, Lattice, Brick, Fuel
+from .phi_membrane import Lattice as PhiCLattice
+
+# ── φC Seed Board: one chessboard boots the whole system ──
+from .phi_meta import MetaBoard, SEED_SLOTS
+
+# ── φC Ports: 4-point board networking (a1/h1/a6/h6 circuitry) ──
+from .phi_membrane import NETWORK_PORTS, PORT_CIRCUITRY
+
+# ── φC ProcessorBoard: one board = parallel C processor ──
+from .phi_processor import ProcessorBoard, Block as ProcessorBlock
+
+# ── Unified Dictionary: φ-lang v6 + capability + membrane ──
+from .phi_dict import PhiDictionary
+
+# ── Reference Counters: usage as dictionary meaning ──
+from .phi_refcount import RefCounter
+
+# ── Capability Library: dict = locations, libraries = real scripts ──
+from .phi_lib import CapabilityLibrary
+
+# ── Per-method library resolution (capability:method -> exact C file) ──
+from .phi_lib import METHOD_INDEX
+
+# ── Gzip-by-default φ-lang storage (the final step, always) ──
+from .phi_gzip import phi_pack, phi_unpack, phi_store, phi_load
+
+# ── Genesis membranes: C library classified into membrane subfolders ──
+from .genesis import build_genesis, load_genesis, save_genesis
+
+# ── Script Finder: synthesize capabilities from the C library ──
+from .phi_finder import ScriptFinder
+
+# ── φ Phrases = Board Configurations; Membranes = deterministic ranges ──
+from .phi_phrases import (phrase_to_config, config_to_phrase,
+                          software_identity, membrane_ranges,
+                          membrane_of, range_call)
+
+# ── Neuron blocks: N inputs (1-3) -> ONE output, stateless ──
+from .phi_neuron import Block as NeuronBlock, NeuronBoard
+
+# ── Hypergeometry: block cube -> board cube -> 4D membrane cube ──
+from .phi_hyper import BlockCube, BoardCube, MembraneCube, LatticeCube, HalfBrickCube, FullBrickCube, hyper_scale, hyper_scale_full

chlang-0.1.0/chlang/brain/__init__.py

@@ -0,0 +1,17 @@
+"""brain — φ-lang v6 Brain Engine module.
+
+Decision dictionary runtime. Particle simulation engine.
+Harvest libraries. Route decisions. Observe emergence.
+
+Usage:
+  from chlang.brain import Brain
+  
+  brain = Brain()
+  brain.spawn("ether", "math_domain")
+  brain.run(".>.>.")
+"""
+
+from .brain import Brain, ETHER, MESH, NODE
+from .mesh_engine import MeshEngine
+
+__all__ = ["Brain", "ETHER", "MESH", "NODE", "MeshEngine"]