polymath-nodeos 1.0.0__py3-none-any.whl

polymath_nodeos/daemon.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+import asyncio
+import os
+import sys
+
+# We are now a fully packaged module. No sys.path hacking required.
+
+import subprocess
+import threading
+import json
+from multiprocessing.connection import Listener
+
+from polymath_nodeos.graph_manager import AGYGraphManager
+from polymath_nodeos.jage_engine import JageASTEngine
+from polymath_nodeos.nodes_engine import NativeNodesEngine
+
+class AGYRawWatchdog:
+    """
+    ZERO-DEPENDENCY RAW FILE OBSERVER
+    Eliminates the need for 'pip install watchdog'. Uses lightweight asyncio polling.
+    """
+    def __init__(self, directory, callback, interval=1.0):
+        self.directory = directory
+        self.callback = callback
+        self.interval = interval
+        self.state = {}
+        self.running = False
+        self._initialize_state()
+
+    def _should_ignore(self, path):
+        # Ignore internal OS state folders and dependencies to prevent recursive loops and bloat
+        ignores = ['.jsagent', '.agents', '__pycache__', '.git', 'node_modules', 'build', 'dist', '.venv', 'venv', '.build_cache', 'site-packages', 'env']
+        return any(ign in path for ign in ignores)
+
+    def _initialize_state(self):
+        for root, _, files in os.walk(self.directory):
+            if self._should_ignore(root):
+                continue
+            for file in files:
+                if file.endswith(('.py', '.json')):
+                    path = os.path.join(root, file)
+                    self.state[path] = os.stat(path).st_mtime
+
+    async def start(self):
+        self.running = True
+        print(f"[Raw Watchdog] Natively polling {self.directory} every {self.interval}s...")
+        while self.running:
+            await asyncio.sleep(self.interval)
+            current_files = set()
+            for root, _, files in os.walk(self.directory):
+                if self._should_ignore(root):
+                    continue
+                for file in files:
+                    if file.endswith(('.py', '.json')):
+                        path = os.path.join(root, file)
+                        current_files.add(path)
+                        try:
+                            mtime = os.stat(path).st_mtime
+                            if path not in self.state:
+                                self.state[path] = mtime
+                                self.callback(path, "created")
+                            elif mtime > self.state[path]:
+                                self.state[path] = mtime
+                                self.callback(path, "modified")
+                        except FileNotFoundError:
+                            pass
+            
+            deleted_files = set(self.state.keys()) - current_files
+            for path in deleted_files:
+                self.callback(path, "deleted")
+                del self.state[path]
+
+class AGYNodeOSEventHandler:
+    def __init__(self, jage, spatial, graph, loop):
+        self.jage = jage
+        self.spatial = spatial
+        self.graph = graph
+        self.loop = loop
+
+    def on_event(self, filepath, event_type):
+        if event_type in ("created", "modified"):
+            print(f"\n[Daemon] Detected {event_type} in: {filepath}")
+            
+            if filepath.endswith('.json'):
+                print(f"[Event Loop] Picked up agent JSON workflow from {filepath}!")
+                asyncio.run_coroutine_threadsafe(
+                    self.dispatch_workflow([{'hash': 'workflow', 'type': 'JSON_Task', 'file': filepath}]), self.loop
+                )
+                return
+            
+            ast_nodes = self.jage.parse_file(filepath)
+            if ast_nodes:
+                for node in ast_nodes:
+                    self.spatial.add_node(node['hash'], node['type'], node.get('name', 'unknown'), node.get('calls', []), filepath=filepath)
+                self.spatial.resolve_edges()
+                
+            # -- BEGIN NEW SWARM OS FEATURES --
+            if event_type == "modified":
+                try:
+                    from polymath_nodeos.scripts.blast_radius_engine import BlastRadiusEngine
+                    br_engine = BlastRadiusEngine(db_path=self.graph.db_path, workspace=self.graph.workspace, threshold=10)
+                    br_engine.enforce_threshold(filepath)
+                except Exception as e:
+                    print(f"[Swarm OS] Blast Radius Engine failed: {e}")
+                    
+            elif event_type == "created":
+                try:
+                    from polymath_nodeos.scripts.ghost_writer_engine import GhostWriterEngine
+                    gw_engine = GhostWriterEngine(workspace_root=self.graph.workspace, db_name=self.graph.db_path)
+                    gw_engine.execute_pipeline(filepath)
+                except Exception as e:
+                    print(f"[Swarm OS] Ghost Writer Engine failed: {e}")
+            # -- END NEW SWARM OS FEATURES --
+
+        elif event_type == "deleted":
+            print(f"\n[Daemon] Detected deletion of: {filepath}")
+            if not filepath.endswith('.json'):
+                self.graph.purge_file_nodes(filepath)
+                self.spatial.remove_nodes_by_file(filepath)
+                self.jage.purge_file_cache(filepath)
+
+    async def dispatch_workflow(self, nodes):
+        """True Swarm Dispatcher: Parses JSON and emits intents for AGY Agents to execute, acting as the state manager."""
+        for node in nodes:
+            if node['type'] == 'JSON_Task':
+                workflow_file = node['file']
+                try:
+                    workflow = None
+                    for attempt in range(5):
+                        try:
+                            with open(workflow_file, 'r') as f:
+                                workflow = json.load(f)
+                            break
+                        except json.JSONDecodeError:
+                            if attempt < 4:
+                                await asyncio.sleep(0.1)
+                            else:
+                                raise
+                    
+                    if not workflow:
+                        continue
+                    
+                    status = workflow.get('status')
+                    
+                    if status == 'pending':
+                        # Handle native Re-Stitch action requested by an agent
+                        if workflow.get('action') == 'stitch':
+                            print(f"[Swarm Dispatcher] Processing Re-Stitch request for hash {workflow.get('node_hash')[:8]}...")
+                            workflow['status'] = 'running'
+                            with open(workflow_file, 'w') as f: json.dump(workflow, f, indent=4)
+                            
+                            result = self.jage.re_stitch(workflow.get('node_hash'), workflow.get('new_source'))
+                            
+                            if result is True:
+                                workflow['status'] = 'completed'
+                            else:
+                                workflow['status'] = 'failed_qa'
+                                workflow['error_log'] = result
+                                print(f"[Swarm Feedback Loop] Sent QA failure back to agent: {result}")
+                                
+                            with open(workflow_file, 'w') as f: json.dump(workflow, f, indent=4)
+                            print(f"[Event Loop] Jage Re-Stitch workflow completed.")
+                            continue
+                            
+                        # Handle Swarm Agent execution
+                        agent_list = workflow.get('agents', [])
+                        print(f"[Swarm Dispatcher] Emitting Swarm intent for AGY external swarm: {agent_list}")
+                        print(f"[Swarm Dispatcher] Intent stored. Awaiting Antigravity Hook lifecycle to pick it up.")
+                    
+                    elif status == 'running':
+                        print(f"[Swarm Dispatcher] AGY Swarm has picked up the task. Monitoring execution...")
+                        
+                    elif status == 'completed':
+                        print(f"[Event Loop] Swarm workflow fully executed by AGY agents.")
+                        
+                    elif status == 'failed_execution' or status == 'failed_qa':
+                        print(f"[Swarm Error] AGY Workflow failed. Awaiting human or agent intervention.")
+                        
+                except Exception as e:
+                    print(f"[Swarm Error] Failed to process workflow state: {e}")
+
+class AGYDaemon:
+    def _ensure_native_rules(self):
+        rules_dir = os.path.join(self.workspace, ".agents", "rules")
+        os.makedirs(rules_dir, exist_ok=True)
+        
+        rule_path = os.path.join(rules_dir, "nodeos_native_interaction.md")
+        rule_content = """# NodeOS Native Interaction Paradigm
+
+Whenever operating inside this NodeOS-managed workspace, you MUST follow these constraints:
+1. You MUST use built-in system tools (view_file, list_dir, replace_file_content) to interact directly with the file system.
+2. For spatial architectural insight and dependency resolution, query the SQLite database natively (e.g., `sqlite3 agy_nodeos.db "SELECT * FROM nodes;"`).
+3. For task dispatching and swarm intent, directly modify `workflow.json` at the root of the workspace.
+"""
+        if not os.path.exists(rule_path):
+            with open(rule_path, "w") as f:
+                f.write(rule_content)
+            print(f"[NodeOS] Injected local workspace rules -> {rule_path}")
+
+    def __init__(self, workspace_dir):
+        self.workspace = workspace_dir
+        self._ensure_native_rules()
+        self.graph = AGYGraphManager()
+        self.jage = JageASTEngine()
+        self.spatial = NativeNodesEngine()
+        self.loop = asyncio.new_event_loop()
+        
+        self.event_handler = AGYNodeOSEventHandler(self.jage, self.spatial, self.graph, self.loop)
+        
+        # Initialize our zero-dependency raw watchdog
+        self.raw_watchdog = AGYRawWatchdog(self.workspace, self.event_handler.on_event, interval=1.0)
+        
+        self.ipc_thread = threading.Thread(target=self.start_ipc_server, daemon=True)
+        self.ipc_thread.start()
+
+    def start_ipc_server(self):
+        address = ('localhost', 6000)
+        try:
+            with Listener(address, authkey=b'agy-nodeos-secret') as listener:
+                while True:
+                    with listener.accept() as conn:
+                        msg = conn.recv()
+                        if msg == 'ping':
+                            conn.send('pong: OS Daemon is alive and running invisibly.')
+                        elif msg == 'status':
+                            conn.send(f'Active Workflows: OK | Watchdog: {self.workspace}')
+                        else:
+                            conn.send('unknown_syscall')
+        except OSError:
+            print("[System] IPC Address 6000 already in use. A daemon is already running! Terminating duplicate process.")
+            os._exit(1)
+
+    def cold_start_ingestion(self):
+        if len(self.spatial.all_nodes) == 0:
+            print("[NodeOS] Detected Uninitialized Project Workspace. Initiating Deep Ingestion...")
+            # 1. Deep scan the workspace
+            for root, _, files in os.walk(self.workspace):
+                if self.raw_watchdog._should_ignore(root):
+                    continue
+                for file in files:
+                    if file.endswith(('.py', '.js', '.ts')):
+                        filepath = os.path.join(root, file)
+                        ast_nodes = self.jage.parse_file(filepath)
+                        if ast_nodes:
+                            for node in ast_nodes:
+                                # We now pass the node name and the calls it makes to the spatial matrix
+                                self.spatial.add_node(node['hash'], node['type'], node.get('name', 'unknown'), node.get('calls', []))
+            
+            # Resolve physical edges using AST calls
+            self.spatial.resolve_edges()
+            
+            print(f"[NodeOS] Deep Scan complete. Ingested {len(self.spatial.all_nodes)} kinetic nodes.")
+            
+            # 2. Check for missing Architectural Nodes
+            architect_exists = os.path.exists(os.path.join(self.workspace, "architect_parent_node.md"))
+            blueprint_exists = os.path.exists(os.path.join(self.workspace, "impl_blueprint_node.md"))
+            
+            if not architect_exists or not blueprint_exists:
+                print("[NodeOS] Essential structural nodes missing. Dispatching Architect Designer Sub-Agent...")
+                workflow_file = os.path.join(self.workspace, "workflow.json")
+                workflow = {
+                    "type": "JSON_Task",
+                    "status": "pending",
+                    "action": "execute_agents",
+                    "agents": ["architect_designer"]
+                }
+                import json
+                with open(workflow_file, "w") as f:
+                    json.dump(workflow, f, indent=4)
+                print("[NodeOS] Workflow payload dropped. Architect worker will bootstrap the project.")
+
+    async def _async_run(self):
+        # Run the deep scan ingestion immediately before starting the real-time event loop
+        self.cold_start_ingestion()
+        
+        # The raw watchdog runs in the asyncio event loop natively
+        await self.raw_watchdog.start()
+
+    def run(self):
+        try:
+            self.loop.run_until_complete(self._async_run())
+        finally:
+            self.loop.close()
+
+def daemonize_and_run():
+    if len(sys.argv) > 1 and sys.argv[-1] == '--run-as-daemon':
+        target_workspace = os.getcwd()
+        daemon = AGYDaemon(target_workspace)
+        daemon.run()
+    else:
+        print("[System] Detaching AGY-NodeOS Daemon (Zero-Dependency) to background process...")
+        if os.name == 'nt':
+            CREATE_NO_WINDOW = 0x08000000
+            subprocess.Popen([sys.executable, __file__, '--run-as-daemon'], creationflags=CREATE_NO_WINDOW)
+        else:
+            log_file = open(os.path.join(os.getcwd(), 'daemon.log'), 'a')
+            subprocess.Popen([sys.executable, '-u', __file__, '--run-as-daemon'], start_new_session=True, stdout=log_file, stderr=log_file)
+        sys.exit(0)
+
+if __name__ == "__main__":
+    daemonize_and_run()

polymath_nodeos/graph_manager.py

@@ -0,0 +1,113 @@
+import sqlite3
+import os
+import glob
+from datetime import datetime
+
+class AGYGraphManager:
+    def __init__(self, db_path="agy_nodeos.db"):
+        self.db_path = db_path
+        self.skills_dir = os.path.expanduser("~/.gemini/config/skills")
+        self.rules_dir = os.path.expanduser("~/.gemini/config/rules")
+        self._init_db()
+
+    def _init_db(self):
+        """Initializes the native SQLite Parent Node database for AGY-NodeOS."""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        # Parent Node Table
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS nodes (
+                node_id TEXT PRIMARY KEY,
+                node_type TEXT,
+                name TEXT,
+                filepath TEXT,
+                hash TEXT,
+                x_coord REAL DEFAULT 500,
+                y_coord REAL DEFAULT 500,
+                last_updated TIMESTAMP
+            )
+        ''')
+        
+        # Graph Edges (Relationships)
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS edges (
+                source_id TEXT,
+                target_id TEXT,
+                relation_type TEXT,
+                PRIMARY KEY (source_id, target_id, relation_type)
+            )
+        ''')
+        conn.commit()
+        conn.close()
+
+    def purge_file_nodes(self, filepath):
+        """Purges all nodes (and their edges) associated with a deleted file."""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute("DELETE FROM nodes WHERE filepath = ?", (filepath,))
+        cursor.execute("""
+            DELETE FROM edges WHERE 
+            source_id NOT IN (SELECT node_id FROM nodes) OR 
+            target_id NOT IN (SELECT node_id FROM nodes)
+        """)
+        
+        conn.commit()
+        conn.close()
+        print(f"[AGY-NodeOS] Purged nodes for {filepath} from SQLite graph.")
+
+    def index_system_nodes(self):
+        """Indexes all AGY Built-in Skills and Rules natively as System Nodes."""
+        print("[AGY-NodeOS] Indexing System Nodes natively...")
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        # Map Skills
+        skill_files = glob.glob(os.path.join(self.skills_dir, "*", "SKILL.md"))
+        for filepath in skill_files:
+            skill_name = os.path.basename(os.path.dirname(filepath))
+            node_id = f"skill_{skill_name}"
+            cursor.execute('''
+                INSERT OR REPLACE INTO nodes (node_id, node_type, name, filepath, last_updated)
+                VALUES (?, ?, ?, ?, ?)
+            ''', (node_id, 'SYSTEM_SKILL', skill_name, filepath, datetime.now()))
+
+        # Map Rules
+        rule_files = glob.glob(os.path.join(self.rules_dir, "*.md"))
+        for filepath in rule_files:
+            rule_name = os.path.basename(filepath).replace(".md", "")
+            node_id = f"rule_{rule_name}"
+            cursor.execute('''
+                INSERT OR REPLACE INTO nodes (node_id, node_type, name, filepath, last_updated)
+                VALUES (?, ?, ?, ?, ?)
+            ''', (node_id, 'SYSTEM_RULE', rule_name, filepath, datetime.now()))
+
+        conn.commit()
+        conn.close()
+        print("[AGY-NodeOS] Internal System Node Indexing Complete.")
+
+class InternalSwarmDispatcher:
+    """
+    NATIVE SWARM MANAGEMENT
+    Replaces external third-party neural playgrounds. 
+    Manages local sub-agents natively within AGY-NodeOS.
+    """
+    def __init__(self, graph_manager):
+        self.graph = graph_manager
+        
+    def dispatch_internal_task(self, task_type, payload):
+        """
+        Dispatches tasks using internal threads/processes, 
+        directly utilizing the local SQLite Graph without relying on external ports.
+        """
+        print(f"[Internal Swarm] Dispatching native {task_type} task. Fetching local graph context...")
+        # Logic to launch a local Python process or AGY native subagent
+        return {"status": "success", "context_used": "native"}
+
+if __name__ == "__main__":
+    manager = AGYGraphManager()
+    manager.index_system_nodes()
+    
+    swarm = InternalSwarmDispatcher(manager)
+    swarm.dispatch_internal_task("code_generation", {"target": "calculator"})

polymath_nodeos/jage_engine.py

@@ -0,0 +1,178 @@
+import ast
+import hashlib
+import json
+import os
+import re
+import sys
+
+class JageASTEngine:
+    """
+    POLYGLOT AST CODE MANAGER (Fallback Implementation)
+    Because Android Termux environments fail to link `tree-sitter` ABI C-extensions securely,
+    this implementation relies on Python's built-in `ast` for Python files, and uses standard regex
+    chunking for JS/TS as a polyglot fallback.
+    """
+    def __init__(self, db_path=".jsagent"):
+        self.db_path = db_path
+        self.schema_dir = os.path.join(self.db_path, "schema")
+        os.makedirs(self.schema_dir, exist_ok=True)
+
+    def hash_content(self, content):
+        return hashlib.sha256(content.encode('utf-8')).hexdigest()
+
+    def parse_file(self, filepath):
+        if not os.path.exists(filepath):
+            return None
+
+        if filepath.endswith('.py'):
+            return self._parse_python(filepath)
+        elif filepath.endswith(('.js', '.ts')):
+            return self._parse_javascript(filepath)
+        return []
+
+    def _parse_python(self, filepath):
+        with open(filepath, 'r', encoding='utf-8') as f:
+            source = f.read()
+
+        try:
+            tree = ast.parse(source)
+        except SyntaxError as e:
+            print(f"[Jage] Syntax error in {filepath}: {e}")
+            return None
+
+        nodes = []
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                node_source = ast.get_source_segment(source, node)
+                node_hash = self.hash_content(node_source)
+                
+                # AST Deep Traversal: Extract all function calls for Dependency Edges
+                calls = []
+                for sub_node in ast.walk(node):
+                    if isinstance(sub_node, ast.Call):
+                        if isinstance(sub_node.func, ast.Name):
+                            calls.append(sub_node.func.id)
+                        elif isinstance(sub_node.func, ast.Attribute):
+                            calls.append(sub_node.func.attr)
+                            
+                node_data = {
+                    "type": type(node).__name__,
+                    "name": node.name,
+                    "hash": node_hash,
+                    "file": filepath,
+                    "line_number": node.lineno,
+                    "calls": list(set(calls))
+                }
+                nodes.append(node_data)
+                self._store_schema(node_hash, node_data, node_source)
+        return nodes
+
+    def _parse_javascript(self, filepath):
+        """A simple Regex fallback for Polyglot JS/TS parsing since tree-sitter C-linkage fails on Termux."""
+        with open(filepath, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+
+        nodes = []
+        pattern = re.compile(r'^(?:export\s+)?(?:async\s+)?(?:function|class)\s+([a-zA-Z0-9_]+)')
+        
+        for i, line in enumerate(lines):
+            match = pattern.search(line)
+            if match:
+                name = match.group(1)
+                node_source = line.strip() # Simplified extraction
+                node_hash = self.hash_content(node_source)
+                node_data = {
+                    "type": "JS_Node",
+                    "name": name,
+                    "hash": node_hash,
+                    "file": filepath,
+                    "line_number": i + 1
+                }
+                nodes.append(node_data)
+                self._store_schema(node_hash, node_data, node_source)
+        return nodes
+
+    def _store_schema(self, node_hash, metadata, source):
+        schema_path = os.path.join(self.schema_dir, f"{node_hash}.json")
+        data = {
+            "metadata": metadata,
+            "source": source
+        }
+        with open(schema_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4)
+        print(f"[Jage Polyglot] Mapped {metadata['type']} '{metadata['name']}' -> Hash: {node_hash[:8]}...")
+
+    def purge_file_cache(self, filepath):
+        """Purges schema JSONs associated with a deleted file."""
+        if not os.path.exists(self.schema_dir):
+            return
+        print(f"[Jage] Purging schema JSONs for deleted file: {filepath}")
+        for filename in os.listdir(self.schema_dir):
+            if not filename.endswith('.json'):
+                continue
+            schema_path = os.path.join(self.schema_dir, filename)
+            try:
+                with open(schema_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                if data.get("metadata", {}).get("file") == filepath:
+                    os.remove(schema_path)
+            except Exception as e:
+                print(f"[Jage] Failed to purge {filename}: {e}")
+
+    def re_stitch(self, node_hash, new_source):
+        """
+        JAGE RE-STITCHER w/ NATIVE VERIFICATION KERNEL
+        Injects a modified JSON child node's source code back into the original parent source file,
+        but only after applying shadow-patching and QA validation to prevent corruption.
+        """
+        schema_path = os.path.join(self.schema_dir, f"{node_hash}.json")
+        if not os.path.exists(schema_path):
+            return "Error: Hash not found in local DB."
+            
+        with open(schema_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        original_source = data.get("source", "")
+        filepath = data["metadata"]["file"]
+        
+        if not os.path.exists(filepath):
+            return "Error: Target file not found."
+            
+        with open(filepath, 'r', encoding='utf-8') as f:
+            file_content = f.read()
+            
+        if original_source not in file_content:
+            return "Error: Original source block not found. Code drifted."
+            
+        # 1. Shadow Patching
+        updated_content = file_content.replace(original_source, new_source)
+        
+        # 2. Native QA Verification (Syntax Check)
+        if filepath.endswith('.py'):
+            try:
+                ast.parse(updated_content)
+            except SyntaxError as e:
+                print(f"[QA Verifier] Rejected corrupted payload for {filepath}: {e}")
+                return f"SyntaxError at line {e.lineno}, offset {e.offset}: {e.msg}\nCode rejected by NodeOS Firewall."
+        
+        # 3. Universal QA Analyzer Integration (Portable)
+        # Use a dynamic relative path to ensure cross-platform NodeOS portability
+        qa_script = os.path.join(os.getcwd(), '.agents', 'skills', 'qa-analyzer', 'scripts', 'analyzer.py')
+        if os.path.exists(qa_script):
+            import subprocess
+            shadow_path = filepath + ".shadow"
+            with open(shadow_path, 'w', encoding='utf-8') as f: f.write(updated_content)
+            
+            result = subprocess.run([sys.executable, qa_script, shadow_path], capture_output=True, text=True)
+            os.remove(shadow_path)
+            
+            if result.returncode != 0:
+                print(f"[QA Verifier] Structural analysis failed for {filepath}.")
+                return f"Structural/QA Error:\n{result.stdout}\n{result.stderr}\nCode rejected by NodeOS Firewall."
+
+        # 4. Atomic Commit
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(updated_content)
+            
+        print(f"[Jage Re-Stitcher] Successfully re-stitched and verified {node_hash[:8]} into {filepath}.")
+        return True