update

Author: RhodosBerger

advanced_cnc_copilot/backend/api/cortex_routes.py

@@ -0,0 +1,49 @@
+from flask import Blueprint, request, jsonify, Response
+from backend.core.cortex_engine import CortexEngine
+import threading
+
+cortex_bp = Blueprint('cortex', __name__)
+
+# Singleton Cortex Instance
+cortex = CortexEngine()
+
+@cortex_bp.route('/cortex/execute', methods=['POST'])
+def execute_job():
+    """
+    Executes a manufacturing profile.
+    JSON Body: { "profile": {...}, "optimize": true }
+    """
+    data = request.json
+    profile = data.get("profile")
+    optimize = data.get("optimize", True)
+
+    def generate():
+        for event in cortex.execute_job(profile, optimize):
+            yield f"{event}\n"
+
+    return Response(generate(), mimetype='text/plain')
+
+@cortex_bp.route('/cortex/evolve', methods=['POST'])
+def evolve_job():
+    """
+    Just runs the discovery engine and returns the optimized profile.
+    """
+    data = request.json
+    profile = data.get("profile")
+    best_mutant = cortex.optimizer.evolve_profile(profile)
+    return jsonify(best_mutant)
+
+@cortex_bp.route('/cortex/status', methods=['GET'])
+def status():
+    """
+    Returns the current Covalent Spectrum state (Hex Trace).
+    """
+    # Create a dummy trace for current state
+    spectrum = cortex.streamer.spectrum.get_state()
+    trace = cortex.streamer.hex_logger.log_trace(spectrum, 999)
+    return jsonify({
+        "status": "ONLINE",
+        "spectrum": str(spectrum),
+        "hex_trace": trace,
+        "mode": "CORTEX_ACTIVE"
+    })

advanced_cnc_copilot/backend/api/synapse_routes.py

@@ -0,0 +1,39 @@
+from flask import Blueprint, request, jsonify, Response, stream_with_context
+import logging
+from backend.cms.services.dopamine_engine import DopamineEngine
+from backend.integrations.synapse.gcode_streamer import GCodeStreamer, MockRepo
+
+synapse_bp = Blueprint('synapse', __name__)
+logger = logging.getLogger(__name__)
+
+# Initialize Engine (Mock Repo for now, or real one)
+repo = MockRepo()
+engine = DopamineEngine(repo)
+streamer = GCodeStreamer(engine)
+
+@synapse_bp.route('/stream', methods=['POST'])
+def stream_gcode():
+    """
+    Endpoint to stream G-Code.
+    Expects textual G-Code in body.
+    Returns a streamed response of processed G-Code lines.
+    """
+    gcode_text = request.data.decode('utf-8')
+    gcode_lines = gcode_text.splitlines()
+
+    def generate():
+        for line in streamer.stream(gcode_lines):
+            yield f"{line}\n"
+
+    return Response(stream_with_context(generate()), mimetype='text/plain')
+
+@synapse_bp.route('/status', methods=['GET'])
+def get_status():
+    """
+    Returns the current status of the Synapse.
+    """
+    return jsonify({
+        "safety_interdictions": streamer.safety_interdictions,
+        "is_paused": streamer.is_paused,
+        "active_machine": streamer.machine_id
+    })

advanced_cnc_copilot/backend/benchmarks/stress_test_cortex.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+echo "Starting Cortex Stress Test..."
+
+# 1. Start Sysbench (CPU Load) in background
+echo "Generating Synthetic Load (Sysbench)..."
+sysbench cpu --cpu-max-prime=10000 --threads=4 run > sysbench_output.log &
+SYSBENCH_PID=$!
+
+# 2. Query Cortex Status while under load
+echo "Querying Cortex API under load..."
+for i in {1..5}; do
+    curl -s http://localhost:5000/cortex/status
+    sleep 1
+done
+
+# 3. Cleanup
+echo "Stopping Load..."
+kill $SYSBENCH_PID
+echo "Test Complete. Check sysbench_output.log for raw metrics."

advanced_cnc_copilot/backend/core/cortex_engine.py

@@ -0,0 +1,62 @@
+import logging
+from typing import Dict, Any, Generator
+
+# Sub-Engines
+try:
+    from backend.cms.services.dopamine_engine import DopamineEngine
+except ImportError:
+    class DopamineEngine: # Mock
+        pass
+
+from backend.core.parallel_streamer import ParallelStreamer
+from backend.core.evolutionary_optimizer import EvolutionaryOptimizer
+from backend.core.hex_logger import HexTraceLogger
+
+class CortexEngine:
+    """
+    The 'Unified Engine' that orchestrates the entire 'Open Mechanic' architecture.
+    Integrates:
+    - Parallel Execution (Streamer)
+    - Discovery (Evolutionary Optimizer)
+    - Tracing (Hex Logger)
+    - Biological Logic (Dopamine Engine)
+    """
+    def __init__(self):
+        self.logger = logging.getLogger("CortexEngine")
+        
+        # 1. Initialize Core Engines
+        self.dopamine = DopamineEngine()
+        self.streamer = ParallelStreamer(self.dopamine)
+        self.optimizer = EvolutionaryOptimizer()
+        self.tracer = HexTraceLogger()
+        
+        self.logger.info("Cortex Engine Initialized. Architecture Extended.")
+
+    def execute_job(self, profile: Dict[str, Any], optimize: bool = True) -> Generator[Dict, None, None]:
+        """
+        Executes a manufacturing job.
+        """
+        self.logger.info(f"Received Job. Optimize={optimize}")
+        
+        # 2. Optimization Phase (Discovery)
+        final_profile = profile
+        if optimize:
+            self.logger.info("Running Evolutionary Optimizer...")
+            final_profile = self.optimizer.evolve_profile(profile)
+            self.logger.info("Optimization Complete. Best Mutant Selected.")
+
+        # 3. Execution Phase (Parallel Streamer)
+        for event in self.streamer.execute_profile(final_profile):
+            # Pass through events
+            yield event
+
+    def run_nightly_discovery(self, profiles: list[Dict]):
+        """
+        Runs the optimizer on a batch of profiles to find new efficiencies overnight.
+        The 'Best Functionalities' you don't know about yet.
+        """
+        results = []
+        for p in profiles:
+            best = self.optimizer.evolve_profile(p)
+            results.append(best)
+        return results

advanced_cnc_copilot/backend/core/covalent_tensors.py

@@ -0,0 +1,49 @@
+import numpy as np
+import threading
+import logging
+
+class TensorSpectrum:
+    """
+    The 'Covalent' Part. 
+    A shared memory spectrum (Tensor) that represents the machine's holistic state.
+    Parallel pools (Neural, Grid) inject their 'Electron Pairs' (Data) into this spectrum.
+
+    Indices:
+    0: Cortisol (Biological Stress)
+    1: Vibration (Physical Instability)
+    2: Grid Risk (Collision Probability)
+    3: Thermal Load (Temperature)
+    """
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.spectrum = np.zeros(4, dtype=np.float32)
+        self.logger = logging.getLogger("Covalent.Spectrum")
+
+    def bond(self, index: int, value: float):
+        """
+        Injects a value into the spectrum (forming a bond).
+        Thread-safe.
+        """
+        with self.lock:
+            # Simple blending logic (Moving Average or Max Hold)
+            self.spectrum[index] = max(self.spectrum[index], value)
+    
+    def dissolve(self):
+        """
+        Decays the spectrum over time (Entropy).
+        """
+        with self.lock:
+            self.spectrum *= 0.95 # Decay factor
+
+    def get_state(self) -> np.ndarray:
+        with self.lock:
+            return self.spectrum.copy()
+            
+    def analyze_stability(self) -> str:
+        """
+        Determines if the covalent bond is stable.
+        """
+        total_energy = np.sum(self.spectrum)
+        if total_energy > 2.0:
+            return "UNSTABLE"
+        return "STABLE"

advanced_cnc_copilot/backend/core/evolutionary_optimizer.py

@@ -0,0 +1,97 @@
+import random
+import copy
+import logging
+from typing import Dict, List
+from backend.integrations.grid_interface import GridInterface
+
+class EvolutionaryOptimizer:
+    """
+    The 'Discovery Engine'. 
+    Uses Genetic Algorithms to explore the parameter space and find 
+    'Functionalities you don't know about' (Novel Optimizations).
+    """
+    def __init__(self):
+        self.grid = GridInterface()
+        self.logger = logging.getLogger("EvoOptimizer")
+        self.population_size = 10
+        self.generations = 5
+
+    def evolve_profile(self, profile: Dict) -> Dict:
+        """
+        Takes a base profile and evolves it to maximize efficiency/stability.
+        Returns the 'Best Mutant'.
+        """
+        self.logger.info("Starting Evolutionary Discovery...")
+        
+        # 1. Initialize Population (Mutants)
+        population = [self._mutate(profile) for _ in range(self.population_size)]
+        
+        for gen in range(self.generations):
+            # 2. Evaluate Fitness via Simulation
+            fitness_scores = []
+            for mutant in population:
+                score = self._evaluate_fitness(mutant)
+                fitness_scores.append((score, mutant))
+            
+            # 3. Selection (Survival of the Fittest)
+            fitness_scores.sort(key=lambda x: x[0], reverse=True)
+            top_performers = [x[1] for x in fitness_scores[:int(self.population_size / 2)]]
+            
+            self.logger.info(f"Generation {gen}: Best Score = {fitness_scores[0][0]}")
+            
+            # 4. Reproduction (Breeding/Mutation)
+            new_population = top_performers[:]
+            while len(new_population) < self.population_size:
+                parent = random.choice(top_performers)
+                child = self._mutate(parent)
+                new_population.append(child)
+            
+            population = new_population
+
+        best_mutant = fitness_scores[0][1]
+        return best_mutant
+
+    def _mutate(self, profile: Dict) -> Dict:
+        """
+        Randomly alters profile parameters (Feed Rate, Strategy).
+        """
+        mutant = copy.deepcopy(profile)
+        for segment in mutant.get("segments", []):
+            # Mutation: Random Feed Rate Adjustment
+            if random.random() < 0.3:
+                feed = segment.get("optimized_feed", 1000)
+                # Try something wild?
+                new_feed = feed * random.uniform(0.8, 1.5) 
+                segment["optimized_feed"] = int(new_feed)
+                
+            # Mutation: Strategy Switch (Novelty)
+            if random.random() < 0.1:
+                segment["strategy"] = random.choice(["trochoidal", "adaptive", "plunge"])
+                
+        return mutant
+
+    def _evaluate_fitness(self, profile: Dict) -> float:
+        """
+        Simulates the profile and assigns a score.
+        Score = Speed - Risk - Energy
+        """
+        total_time = 0
+        risk_penalty = 0
+        
+        for segment in profile.get("segments", []):
+            # Simulation
+            status = self.grid.simulate_segment(segment)
+            if status == "COLLISION":
+                return -1000.0 # Instant Death
+            elif status == "RISK":
+                risk_penalty += 50
+                
+            # Efficiency
+            feed = segment.get("optimized_feed", 1000)
+            dist = 10 # Mock distance
+            time_taken = dist / feed
+            total_time += time_taken
+            
+        # Fitness Function
+        score = (1.0 / total_time) * 1000 - risk_penalty
+        return score

advanced_cnc_copilot/backend/core/hex_logger.py

@@ -0,0 +1,56 @@
+import logging
+import numpy as np
+import binascii
+import struct
+import platform
+import os
+
+class HexTraceLogger:
+    """
+    Advanced Log Composer that creates a Hexadecimal Trace of system links.
+    Captures Covalent State (Numpy), System Info (Conda/Docker), and timestamps.
+    """
+    def __init__(self):
+        self.logger = logging.getLogger("HexTrace")
+        self.system_fingerprint = self._get_system_fingerprint()
+
+    def _get_system_fingerprint(self) -> bytes:
+        """
+        Captures static system info (Platform, Node) as bytes.
+        """
+        uname = platform.uname()
+        info = f"{uname.system}-{uname.release}-{uname.node}"
+        return info.encode('utf-8')[:16].ljust(16, b'\0')
+
+    def compose_trace(self, spectrum: np.ndarray, event_id: int) -> str:
+        """
+        Composes a Hexadecimal Trace String from the current state.
+        Format: [EventID][SystemFP][SpectrumData][CheckSum]
+        """
+        # 1. Event ID (4 bytes)
+        b_id = struct.pack('>I', event_id)
+        
+        # 2. System Fingerprint (16 bytes)
+        b_sys = self.system_fingerprint
+
+        # 3. Spectrum Data (Numpy -> Bytes)
+        # We start with the raw bytes of the float array
+        b_spectrum = spectrum.tobytes()
+        
+        # 4. Compose Payload
+        payload = b_id + b_sys + b_spectrum
+        
+        # 5. Checksum (CRC32)
+        checksum = binascii.crc32(payload)
+        b_checksum = struct.pack('>I', checksum)
+        
+        # 6. Final Hex String
+        final_bytes = payload + b_checksum
+        hex_trace = binascii.hexlify(final_bytes).decode('ascii').upper()
+        
+        return hex_trace
+
+    def log_trace(self, spectrum: np.ndarray, event_id: int):
+        trace = self.compose_trace(spectrum, event_id)
+        self.logger.info(f"TRACE_HEX: {trace}")
+        return trace