polymath-nodeos 1.0.0__py3-none-any.whl

polymath_nodeos/nodes_engine.py

@@ -0,0 +1,246 @@
+import math
+import sqlite3
+import sys
+
+class Point:
+    def __init__(self, x, y, node_id, node_type, mass=1.0, name="unknown", calls=None, filepath=None):
+        self.x = x
+        self.y = y
+        self.vx = 0.0
+        self.vy = 0.0
+        self.fx = 0.0
+        self.fy = 0.0
+        self.mass = mass
+        self.node_id = node_id
+        self.node_type = node_type
+        self.name = name
+        self.calls = calls if calls else []
+        self.edges = []
+        self.filepath = filepath
+
+class Rectangle:
+    def __init__(self, x, y, w, h):
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+
+    def contains(self, point):
+        return (self.x - self.w <= point.x <= self.x + self.w and
+                self.y - self.h <= point.y <= self.y + self.h)
+
+    def intersects(self, range_rect):
+        return not (range_rect.x - range_rect.w > self.x + self.w or
+                    range_rect.x + range_rect.w < self.x - self.w or
+                    range_rect.y - range_rect.h > self.y + self.h or
+                    range_rect.y + range_rect.h < self.y - self.h)
+
+class QuadTree:
+    def __init__(self, boundary, capacity):
+        self.boundary = boundary
+        self.capacity = capacity
+        self.points = []
+        self.divided = False
+
+    def subdivide(self):
+        x, y, w, h = self.boundary.x, self.boundary.y, self.boundary.w / 2, self.boundary.h / 2
+        self.northeast = QuadTree(Rectangle(x + w, y - h, w, h), self.capacity)
+        self.northwest = QuadTree(Rectangle(x - w, y - h, w, h), self.capacity)
+        self.southeast = QuadTree(Rectangle(x + w, y + h, w, h), self.capacity)
+        self.southwest = QuadTree(Rectangle(x - w, y + h, w, h), self.capacity)
+        self.divided = True
+
+    def insert(self, point):
+        if not self.boundary.contains(point):
+            return False
+        if len(self.points) < self.capacity:
+            self.points.append(point)
+            return True
+        if not self.divided:
+            self.subdivide()
+        return (self.northeast.insert(point) or self.northwest.insert(point) or 
+                self.southeast.insert(point) or self.southwest.insert(point))
+
+    def query(self, range_rect, found=None):
+        if found is None: found = []
+        if not self.boundary.intersects(range_rect): return found
+        for p in self.points:
+            if range_rect.contains(p): found.append(p)
+        if self.divided:
+            self.northwest.query(range_rect, found)
+            self.northeast.query(range_rect, found)
+            self.southwest.query(range_rect, found)
+            self.southeast.query(range_rect, found)
+        return found
+
+class NativeNodesEngine:
+    """
+    NATIVE SPATIAL CLUSTERING & PHYSICS ENGINE
+    Implements Force-Directed Graph physics (Repulsion + Gravity + Hooke's Law Springs) and batch SQLite sync.
+    """
+    def __init__(self, db_path='agy_nodeos.db'):
+        self.db_path = db_path
+        self.boundary = Rectangle(500, 500, 500, 500)
+        self.qtree = QuadTree(self.boundary, 4)
+        self.all_nodes = []
+        self.hydrate_from_db()
+
+    def hydrate_from_db(self):
+        print("[Physics Engine] Hydrating spatial matrix from SQLite Database...")
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        try:
+            cursor.execute("SELECT node_id, node_type, x_coord, y_coord, name, filepath FROM nodes")
+            rows = cursor.fetchall()
+            for row in rows:
+                if row[2] is not None and row[3] is not None:
+                    name = row[4] if len(row) > 4 else "unknown"
+                    filepath = row[5] if len(row) > 5 else None
+                    p = Point(row[2], row[3], row[0], row[1], name=name, filepath=filepath)
+                    self.all_nodes.append(p)
+                    self.qtree.insert(p)
+            print(f"[Physics Engine] Hydrated {len(self.all_nodes)} kinetic nodes.")
+        except sqlite3.OperationalError:
+            print("[Physics Engine] Table not initialized. Skipping hydration.")
+        conn.close()
+
+    def rebuild_qtree(self):
+        self.qtree = QuadTree(self.boundary, 4)
+        for p in self.all_nodes:
+            self.qtree.insert(p)
+
+    def resolve_edges(self):
+        """Resolves the string AST calls into physical Point references for Spring Physics."""
+        print("[Physics Engine] Resolving execution call graph into physical edges...")
+        name_to_node = {p.name: p for p in self.all_nodes}
+        edge_count = 0
+        
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        for p in self.all_nodes:
+            for call_name in p.calls:
+                target = name_to_node.get(call_name)
+                if target and target not in p.edges:
+                    p.edges.append(target)
+                    edge_count += 1
+                    try:
+                        cursor.execute('''
+                            INSERT OR IGNORE INTO edges (source_id, target_id, relation_type) 
+                            VALUES (?, ?, "CALL")
+                        ''', (p.node_id, target.node_id))
+                    except sqlite3.OperationalError:
+                        pass # Ignore if edges table missing/already exists
+                        
+        conn.commit()
+        conn.close()
+        print(f"[Physics Engine] Bonded {edge_count} structural connections. Simulating graph clustering...")
+        if edge_count > 0:
+            import threading
+            # Run physics simulation in the background so it doesn't block the Daemon event loop
+            threading.Thread(target=self.simulate_physics, args=(100,), daemon=True).start()
+
+    def simulate_physics(self, ticks=50):
+        """Euler Integration of Coulomb Repulsion, Central Gravity, and Hooke's Law Springs."""
+        damping = 0.85
+        time_step = 1.0
+        k_repulse = 5000.0
+        k_gravity = 0.05
+        k_spring = 0.1  # Hooke's Law spring constant
+        ideal_length = 50.0  # Ideal distance between connected nodes
+        center_x, center_y = 500.0, 500.0
+        
+        for tick in range(ticks):
+            # Rebuild QuadTree for rapid O(N log N) spatial queries
+            self.rebuild_qtree()
+            
+            for node in self.all_nodes:
+                node.fx = (center_x - node.x) * k_gravity
+                node.fy = (center_y - node.y) * k_gravity
+                
+                # Optimized Local Repulsion: Only repel against nodes within 150px radius using QuadTree
+                range_rect = Rectangle(node.x, node.y, 150, 150)
+                nearby_nodes = self.qtree.query(range_rect)
+                
+                for other in nearby_nodes:
+                    if other == node:
+                        continue
+                    dx, dy = node.x - other.x, node.y - other.y
+                    dist_sq = dx**2 + dy**2
+                    if dist_sq > 0:
+                        force = k_repulse / dist_sq
+                        dist = math.sqrt(dist_sq)
+                        node.fx += force * (dx / dist)
+                        node.fy += force * (dy / dist)
+                        
+            # Hooke's Law Spring Attraction between CONNECTED nodes
+            for n1 in self.all_nodes:
+                for n2 in n1.edges:
+                    dx, dy = n2.x - n1.x, n2.y - n1.y
+                    dist = math.sqrt(dx**2 + dy**2)
+                    if dist > 0:
+                        force = k_spring * (dist - ideal_length)
+                        fx = force * (dx / dist)
+                        fy = force * (dy / dist)
+                        n1.fx += fx
+                        n1.fy += fy
+                        n2.fx -= fx
+                        n2.fy -= fy
+
+            # Euler Integration
+            for node in self.all_nodes:
+                ax = node.fx / node.mass
+                ay = node.fy / node.mass
+                node.vx = (node.vx + ax * time_step) * damping
+                node.vy = (node.vy + ay * time_step) * damping
+                node.x += node.vx * time_step
+                node.y += node.vy * time_step
+                
+        self.rebuild_qtree()
+        self.sync_to_sqlite()
+        sys.stderr.write(f"[Physics Engine] Successfully settled {len(self.all_nodes)} nodes. Syncing to SQLite.\n")
+
+    def sync_to_sqlite(self):
+        """Batch update physical positions to SQLite to save I/O overhead."""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        for p in self.all_nodes:
+            cursor.execute('''
+                INSERT INTO nodes (node_id, node_type, name, filepath, x_coord, y_coord, last_updated)
+                VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+                ON CONFLICT(node_id) DO UPDATE SET 
+                    name=excluded.name, 
+                    filepath=excluded.filepath,
+                    x_coord=excluded.x_coord, 
+                    y_coord=excluded.y_coord, 
+                    last_updated=excluded.last_updated
+            ''', (p.node_id, p.node_type, p.name, p.filepath, p.x, p.y))
+        conn.commit()
+        conn.close()
+
+    def remove_nodes_by_file(self, filepath):
+        """Removes all spatial nodes belonging to a deleted file."""
+        sys.stderr.write(f"[Physics Engine] Removing spatial nodes for deleted file: {filepath}\n")
+        self.all_nodes = [node for node in self.all_nodes if node.filepath != filepath]
+        for node in self.all_nodes:
+            node.edges = [e for e in node.edges if e.filepath != filepath]
+        self.rebuild_qtree()
+
+    def add_node(self, node_id, node_type, name="unknown", calls=None, parent_x=500, parent_y=500, filepath=None):
+        import random
+        drop_x = parent_x + random.uniform(-10, 10)
+        drop_y = parent_y + random.uniform(-10, 10)
+        
+        existing = next((n for n in self.all_nodes if n.node_id == node_id), None)
+        if not existing:
+            p = Point(drop_x, drop_y, node_id, node_type, name=name, calls=calls, filepath=filepath)
+            self.all_nodes.append(p)
+            sys.stderr.write(f"[Physics Engine] Dropped {node_type} '{name}' into kinetic simulation.\n")
+            return p
+        else:
+            existing.name = name
+            if filepath:
+                existing.filepath = filepath
+            if calls:
+                existing.calls = calls
+            return existing

polymath_nodeos/scripts/agy_invoke.py

@@ -0,0 +1,20 @@
+import sys
+import json
+import telemetry
+
+def invoke(payload_str):
+    try:
+        workflow = json.loads(payload_str)
+        with open('workflow.json', 'w') as f:
+            json.dump(workflow, f, indent=4)
+        
+        # Now natively stream the NodeOS telemetry to AGY's sys.stdout
+        telemetry.track_workflow('workflow.json')
+    except Exception as e:
+        print(f"Failed to invoke workflow: {e}")
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        invoke(sys.argv[1])
+    else:
+        print("Usage: python agy_invoke.py '<json_string>'")

polymath_nodeos/scripts/blast_radius_engine.py

@@ -0,0 +1,127 @@
+import sqlite3
+import json
+import os
+import logging
+from typing import Optional
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - [%(levelname)s] - %(message)s')
+logger = logging.getLogger(__name__)
+
+class BlastRadiusEngine:
+    """
+    Engine to calculate the blast radius of file modifications using a Recursive CTE
+    against the NodeOS SQLite graph.
+    """
+    
+    def __init__(self, db_path: str, workspace: str, threshold: int = 10):
+        self.db_path = db_path
+        self.workspace = workspace
+        self.threshold = threshold
+
+    def get_blast_radius(self, filepath: str) -> int:
+        """
+        Calculates the number of downstream nodes that depend on the given filepath.
+        
+        Args:
+            filepath: The path of the modified file.
+            
+        Returns:
+            int: The number of distinct downstream nodes impacted.
+        """
+        if not os.path.exists(self.db_path):
+            logger.error(f"Database not found at {self.db_path}")
+            return 0
+
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                
+                query = '''
+                    WITH RECURSIVE downstream AS (
+                        -- Base Case: Nodes that directly call nodes in the modified file
+                        SELECT e.source_id 
+                        FROM edges e 
+                        JOIN nodes n ON e.target_id = n.node_id 
+                        WHERE n.filepath = ?
+                        
+                        UNION
+                        
+                        -- Recursive Step: Nodes that call the nodes found in the previous step
+                        SELECT e.source_id
+                        FROM edges e
+                        INNER JOIN downstream d ON e.target_id = d.source_id
+                    )
+                    SELECT COUNT(DISTINCT source_id) FROM downstream;
+                '''
+                cursor.execute(query, (filepath,))
+                result = cursor.fetchone()
+                return result[0] if result else 0
+        except sqlite3.Error as e:
+            logger.error(f"SQLite error while calculating blast radius: {e}")
+            return 0
+
+    def enforce_threshold(self, filepath: str) -> None:
+        """
+        Checks the blast radius for the filepath and emits warnings if it exceeds the threshold.
+        
+        Args:
+            filepath: The path of the modified file.
+        """
+        radius_count = self.get_blast_radius(filepath)
+        logger.info(f"Blast radius for {filepath}: {radius_count} downstream nodes.")
+
+        if radius_count > self.threshold:
+            logger.warning(f"High Blast Radius ({radius_count} dependents) for {filepath}")
+            self._drop_intent(filepath, radius_count)
+            self._write_warning_file(filepath, radius_count)
+
+    def _drop_intent(self, filepath: str, radius_count: int) -> None:
+        """
+        Drops a workflow.json intent to notify the agent swarm.
+        """
+        workflow_file = os.path.join(self.workspace, "workflow.json")
+        workflow = {
+            "type": "JSON_Task",
+            "status": "pending",
+            "action": "blast_radius_warning",
+            "target_file": filepath,
+            "impacted_nodes_count": radius_count
+        }
+        
+        try:
+            with open(workflow_file, 'w') as f:
+                json.dump(workflow, f, indent=4)
+            logger.info(f"Dropped intent at {workflow_file}")
+        except IOError as e:
+            logger.error(f"Failed to write workflow.json: {e}")
+
+    def _write_warning_file(self, filepath: str, radius_count: int) -> None:
+        """
+        Writes a warning.md file in the same directory as the modified file.
+        """
+        warning_path = os.path.join(os.path.dirname(filepath), "warning.md")
+        
+        content = (
+            f"# High Blast Radius Warning\n"
+            f"Modifying `{filepath}` impacts {radius_count} downstream nodes. "
+            f"Proceed with caution.\n"
+        )
+        
+        try:
+            with open(warning_path, 'w') as w_file:
+                w_file.write(content)
+            logger.info(f"Wrote warning markdown at {warning_path}")
+        except IOError as e:
+            logger.error(f"Failed to write warning.md: {e}")
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="Calculate Blast Radius for a file in AGY-NodeOS.")
+    parser.add_argument("--db", required=True, help="Path to agy_nodeos.db")
+    parser.add_argument("--workspace", required=True, help="Path to workspace root")
+    parser.add_argument("--file", required=True, help="Modified filepath to check")
+    parser.add_argument("--threshold", type=int, default=10, help="Blast radius threshold")
+    
+    args = parser.parse_args()
+    engine = BlastRadiusEngine(db_path=args.db, workspace=args.workspace, threshold=args.threshold)
+    engine.enforce_threshold(args.file)

polymath_nodeos/scripts/dead_code_engine.py

@@ -0,0 +1,103 @@
+import sqlite3
+import json
+import os
+import time
+from typing import List, Dict, Any
+from dataclasses import dataclass
+
+@dataclass
+class OrphanedNode:
+    node_id: str
+    filepath: str
+    node_type: str
+
+class SemanticDeadCodeEngine:
+    """
+    Advanced engine for eradicating semantic dead code in AGY-NodeOS.
+    Queries the SQLite dependency graph to identify orphaned nodes
+    and generates swarm intents for safe deletion.
+    """
+    
+    def __init__(self, db_path: str, workspace_root: str):
+        self.db_path = db_path
+        self.workspace_root = workspace_root
+        self.workflow_path = os.path.join(self.workspace_root, "workflow.json")
+        
+    def check_database_exists(self) -> bool:
+        """Verifies if the agy_nodeos.db exists."""
+        return os.path.exists(self.db_path)
+        
+    def find_orphaned_nodes(self) -> List[OrphanedNode]:
+        """
+        Executes the SQL query to find nodes with 0 incoming edges.
+        Excludes 'entry_point' nodes to prevent removing roots.
+        """
+        if not self.check_database_exists():
+            raise FileNotFoundError(f"Database not found at {self.db_path}")
+            
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            query = """
+                SELECT n.node_id, n.filepath, n.node_type
+                FROM nodes n
+                LEFT JOIN edges e ON n.node_id = e.target_id
+                WHERE e.source_id IS NULL 
+                  AND n.node_type != 'entry_point';
+            """
+            cursor.execute(query)
+            rows = cursor.fetchall()
+            
+        return [OrphanedNode(node_id=r[0], filepath=r[1], node_type=r[2]) for r in rows]
+
+    def _build_intent_payload(self, nodes: List[OrphanedNode]) -> Dict[str, Any]:
+        """Constructs the intent JSON payload based on NodeOS schema."""
+        targets = [
+            {
+                "id": node.node_id,
+                "file_path": node.filepath,
+                "action": "delete"
+            }
+            for node in nodes
+        ]
+        
+        return {
+            "intent": "eradicate_dead_code",
+            "status": "Pending",
+            "targets": targets,
+            "context": "Node has 0 incoming edges in agy_nodeos.db",
+            "timestamp": time.time()
+        }
+
+    def generate_deletion_intents(self) -> None:
+        """
+        Identifies orphaned nodes and dispatches a deletion intent to workflow.json.
+        """
+        orphans = self.find_orphaned_nodes()
+        if not orphans:
+            print("[DeadCodeEngine] No orphaned nodes detected. System clean.")
+            return
+            
+        print(f"[DeadCodeEngine] Discovered {len(orphans)} orphaned nodes. Generating intent...")
+        intent_payload = self._build_intent_payload(orphans)
+        
+        # Write intent to workflow.json to trigger swarm intelligence
+        with open(self.workflow_path, "w") as f:
+            json.dump(intent_payload, f, indent=2)
+            
+        print(f"[DeadCodeEngine] Intent dispatched to {self.workflow_path}")
+
+
+def main():
+    # Resolve paths relative to this script location
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    workspace_root = os.path.abspath(os.path.join(script_dir, ".."))
+    db_path = os.path.join(workspace_root, "agy_nodeos.db")
+    
+    engine = SemanticDeadCodeEngine(db_path=db_path, workspace_root=workspace_root)
+    try:
+        engine.generate_deletion_intents()
+    except Exception as e:
+        print(f"[DeadCodeEngine] Error: {e}")
+
+if __name__ == "__main__":
+    main()

polymath_nodeos/scripts/domino_engine.py

@@ -0,0 +1,93 @@
+import sqlite3
+import json
+import os
+import argparse
+from typing import List
+
+class DominoEngine:
+    """
+    Advanced architecture module for executing the Domino Refactor blueprint.
+    Manages querying the AST call graph and dispatching parallel refactor swarms.
+    """
+    
+    def __init__(self, db_path: str = "agy_nodeos.db", workflow_path: str = "workflow.json"):
+        self.db_path = db_path
+        self.workflow_path = workflow_path
+
+    def find_callers(self, target_hash: str) -> List[str]:
+        """
+        Finds all files calling a specific hash by querying the AST edges.
+        Uses INNER JOIN logic to resolve source and target node filepaths.
+        """
+        if not os.path.exists(self.db_path):
+            raise FileNotFoundError(f"Database not found at path: {self.db_path}")
+
+        query = """
+            SELECT DISTINCT caller.filepath 
+            FROM edges e 
+            JOIN nodes target ON e.target_id = target.node_id 
+            JOIN nodes caller ON e.source_id = caller.node_id 
+            WHERE target.hash = ? AND e.relation_type = 'CALL';
+        """
+        
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute(query, (target_hash,))
+                rows = cursor.fetchall()
+                return [row[0] for row in rows]
+        except sqlite3.Error as e:
+            print(f"Database error during find_callers: {e}")
+            return []
+
+    def generate_intent(self, target_hash: str, callers: List[str]) -> None:
+        """
+        Generates a multi-agent parallel intent payload and writes it to workflow.json.
+        """
+        if not callers:
+            print(f"No callers found for hash '{target_hash}'. No workflow generated.")
+            return
+
+        workflow = {
+            "status": "pending",
+            "agents": []
+        }
+
+        for caller_file in callers:
+            task = {
+                "task": "refactor_domino",
+                "target_file": caller_file,
+                "instruction": f"Refactor function calls invoking hash {target_hash} to align with the newly updated signature."
+            }
+            workflow["agents"].append(task)
+
+        try:
+            with open(self.workflow_path, 'w', encoding='utf-8') as f:
+                json.dump(workflow, f, indent=2)
+            print(f"Successfully dispatched refactor swarm intent for {len(callers)} target files to {self.workflow_path}.")
+        except IOError as e:
+            print(f"IOError writing to {self.workflow_path}: {e}")
+
+    def run_refactor(self, target_hash: str) -> None:
+        """
+        Executes the end-to-end domino refactor chain for a specific hash.
+        """
+        print(f"Starting Domino Refactor for hash: {target_hash}")
+        callers = self.find_callers(target_hash)
+        self.generate_intent(target_hash, callers)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Domino Refactor Engine")
+    parser.add_argument("hash", help="The specific function hash to refactor")
+    parser.add_argument("--db", default="agy_nodeos.db", help="Path to agy_nodeos.db SQLite database")
+    parser.add_argument("--workflow", default="workflow.json", help="Path to output workflow.json payload")
+    
+    args = parser.parse_args()
+    
+    engine = DominoEngine(db_path=args.db, workflow_path=args.workflow)
+    engine.run_refactor(args.hash)
+
+
+if __name__ == "__main__":
+    main()