polymath-nodeos 1.0.0__py3-none-any.whl

polymath_nodeos/scripts/ghost_writer_engine.py

@@ -0,0 +1,135 @@
+import os
+import json
+import sqlite3
+import logging
+from typing import List, Dict, Optional, Tuple
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("GhostWriterEngine")
+
+class GhostWriterEngine:
+    """
+    Advanced Spatial Context Ghost Writing Engine.
+    Leverages physical coordinates to resolve contextual dependencies.
+    """
+    def __init__(self, workspace_root: str, db_name: str = 'agy_nodeos.db'):
+        self.workspace_root = workspace_root
+        self.db_path = os.path.join(workspace_root, db_name) if not os.path.isabs(db_name) else db_name
+
+    def calculate_centroid(self, target_filepath: str) -> Optional[Tuple[float, float]]:
+        """Calculates the center of mass (centroid) of the target file's AST nodes."""
+        logger.info(f"Calculating spatial centroid for {target_filepath}")
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute(
+                    "SELECT AVG(x_coord), AVG(y_coord) FROM nodes WHERE filepath = ?", 
+                    (target_filepath,)
+                )
+                row = cursor.fetchone()
+                
+                if row and row[0] is not None and row[1] is not None:
+                    return float(row[0]), float(row[1])
+        except sqlite3.Error as e:
+            logger.error(f"Database error during centroid calculation: {e}")
+        
+        return None
+
+    def find_nearest_neighbors(self, cx: float, cy: float, target_filepath: str, k: int = 10) -> List[Tuple[str, str, str]]:
+        """Queries the physics engine DB for the K-nearest physical neighbors using squared distance."""
+        logger.info(f"Querying top {k} physical neighbors from ({cx:.2f}, {cy:.2f})")
+        neighbors = []
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                # Optimized Euclidean squared-distance query
+                cursor.execute("""
+                    SELECT node_id, filepath, name, 
+                           ((x_coord - ?)*(x_coord - ?) + (y_coord - ?)*(y_coord - ?)) AS dist 
+                    FROM nodes 
+                    WHERE filepath != ? 
+                    ORDER BY dist ASC 
+                    LIMIT ?
+                """, (cx, cx, cy, cy, target_filepath, k))
+                
+                rows = cursor.fetchall()
+                for row in rows:
+                    neighbors.append((row[0], row[1], row[2]))
+        except sqlite3.Error as e:
+            logger.error(f"Database error during neighbor resolution: {e}")
+            
+        return neighbors
+
+    def extract_ast_signatures(self, neighbors: List[Tuple[str, str, str]]) -> List[Dict[str, str]]:
+        """Extracts AST signatures from .jsagent/schema files for the resolved neighbors."""
+        spatial_context = []
+        for node_id, filepath, name in neighbors:
+            schema_path = os.path.join(self.workspace_root, '.jsagent', 'schema', f"{node_id}.json")
+            signature = ""
+            
+            if os.path.exists(schema_path):
+                try:
+                    with open(schema_path, 'r', encoding='utf-8') as f:
+                        schema_data = json.load(f)
+                        signature = schema_data.get('source', '')
+                except (json.JSONDecodeError, IOError) as e:
+                    logger.warning(f"Failed to read AST schema for node {node_id}: {e}")
+            else:
+                logger.debug(f"Schema not found for node {node_id} at {schema_path}")
+                
+            spatial_context.append({
+                "node_name": name,
+                "filepath": filepath,
+                "signature": signature
+            })
+            
+        return spatial_context
+
+    def emit_workflow_intent(self, target_filepath: str, spatial_context: List[Dict[str, str]]) -> bool:
+        """Bundles the context payload and drops it into workflow.json for the NodeOS daemon."""
+        logger.info(f"Bundling {len(spatial_context)} contextual signatures into workflow intent.")
+        workflow_payload = {
+            "type": "JSON_Task",
+            "status": "pending",
+            "action": "ghost_write",
+            "target_file": target_filepath,
+            "spatial_context": spatial_context
+        }
+        
+        workflow_path = os.path.join(self.workspace_root, 'workflow.json')
+        try:
+            with open(workflow_path, 'w', encoding='utf-8') as f:
+                json.dump(workflow_payload, f, indent=4)
+            logger.info("Successfully dropped intent into workflow.json")
+            return True
+        except IOError as e:
+            logger.error(f"Failed to emit workflow intent: {e}")
+            return False
+
+    def execute_pipeline(self, target_filepath: str) -> bool:
+        """Executes the full Ghost Writer pipeline."""
+        centroid = self.calculate_centroid(target_filepath)
+        if not centroid:
+            logger.warning("Aborting pipeline: Centroid could not be calculated.")
+            return False
+            
+        cx, cy = centroid
+        neighbors = self.find_nearest_neighbors(cx, cy, target_filepath)
+        
+        if not neighbors:
+            logger.warning("No spatial neighbors found for context.")
+        
+        spatial_context = self.extract_ast_signatures(neighbors)
+        return self.emit_workflow_intent(target_filepath, spatial_context)
+
+if __name__ == "__main__":
+    import sys
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Spatial Context Ghost Writer Engine")
+    parser.add_argument("target_file", help="The newly created file to ghost write")
+    parser.add_argument("--workspace", default=os.getcwd(), help="Root directory of the NodeOS workspace")
+    args = parser.parse_args()
+
+    engine = GhostWriterEngine(workspace_root=args.workspace)
+    engine.execute_pipeline(args.target_file)

polymath_nodeos/scripts/intent_injector.py

@@ -0,0 +1,32 @@
+import json
+import os
+
+WORKFLOW_FILE = os.path.join(os.getcwd(), "workflow.json")
+
+def main():
+    if not os.path.exists(WORKFLOW_FILE):
+        print("{}")
+        return
+        
+    try:
+        with open(WORKFLOW_FILE, "r") as f:
+            data = json.load(f)
+            
+        status = data.get("status")
+        if status == "pending":
+            message = f"NodeOS emitted an intent. Please fulfill this workflow:\n{json.dumps(data, indent=2)}"
+            response = {
+                "injectSteps": [
+                    {
+                        "ephemeralMessage": message
+                    }
+                ]
+            }
+            print(json.dumps(response))
+        else:
+            print("{}")
+    except Exception:
+        print("{}")
+
+if __name__ == "__main__":
+    main()

polymath_nodeos/scripts/intent_stopper.py

@@ -0,0 +1,28 @@
+import json
+import os
+
+WORKFLOW_FILE = os.path.join(os.getcwd(), "workflow.json")
+
+def main():
+    if not os.path.exists(WORKFLOW_FILE):
+        print("{}")
+        return
+        
+    try:
+        with open(WORKFLOW_FILE, "r") as f:
+            data = json.load(f)
+            
+        status = data.get("status")
+        if status in ["pending", "running"]:
+            response = {
+                "decision": "continue",
+                "reason": f"NodeOS has an active intent with status '{status}'. Please process it."
+            }
+            print(json.dumps(response))
+        else:
+            print("{}")
+    except Exception:
+        print("{}")
+
+if __name__ == "__main__":
+    main()

polymath_nodeos/scripts/ipc_hook.py

@@ -0,0 +1,27 @@
+import sys
+from multiprocessing.connection import Client
+
+def send_ipc_syscall(command):
+    """
+    Cross-platform IPC Hook.
+    Acts as a syscall client to securely communicate with the invisible AGY-NodeOS background daemon.
+    """
+    address = ('localhost', 6000)
+    try:
+        # Connect to the IPC Listener opened by the daemon
+        with Client(address, authkey=b'agy-nodeos-secret') as conn:
+            conn.send(command)
+            response = conn.recv()
+            print(f"[IPC Hook Response]: {response}")
+    except ConnectionRefusedError:
+        print("[IPC Error] Connection refused. Is the background daemon running?")
+    except Exception as e:
+        print(f"[IPC Error] {e}")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python ipc_hook.py [ping|status]")
+        sys.exit(1)
+        
+    syscall_command = sys.argv[1]
+    send_ipc_syscall(syscall_command)

polymath_nodeos/scripts/legacy_math.py

@@ -0,0 +1,3 @@
+def calculate_tax(amount):
+    print("Calculating heavily optimized legacy tax")
+    return amount * 0.12

polymath_nodeos/scripts/telemetry.py

@@ -0,0 +1,69 @@
+import time
+import json
+import os
+import sys
+
+def tail_agent_logs(log_file="daemon.log"):
+    """Yields new lines from the log file, filtering only Agent actions."""
+    if not os.path.exists(log_file):
+        return
+    with open(log_file, "r") as f:
+        f.seek(0, os.SEEK_END)
+        while True:
+            line = f.readline()
+            if not line:
+                time.sleep(0.1)
+                yield None
+            else:
+                # Filter out background OS noise, only show Swarm and Agent actions
+                if any(noise in line for noise in ["[Physics Engine]", "[Raw Watchdog]", "[Jage Polyglot]", "[Daemon]", "[NodeOS] Deep Scan"]):
+                    yield None
+                else:
+                    yield line
+
+def track_workflow(workflow_file="workflow.json"):
+    if not os.path.exists(workflow_file):
+        print("\033[93m[NodeOS] No active workflow detected in workspace.\033[0m")
+        return
+
+    last_status = None
+    log_generator = tail_agent_logs()
+    
+    while True:
+        # Print filtered agent action logs
+        if log_generator:
+            log_line = next(log_generator, None)
+            while log_line:
+                sys.stdout.write(f"\033[90m{log_line}\033[0m")
+                sys.stdout.flush()
+                log_line = next(log_generator, None)
+
+        try:
+            with open(workflow_file, 'r') as f:
+                data = json.load(f)
+            status = data.get('status', 'unknown')
+            
+            if status != last_status:
+                if status == 'pending':
+                    agents = ", ".join(data.get('agents', []))
+                    intent = data.get('action', 'execute_agents')
+                    print(f"\n\033[96m[NodeOS Swarm] Intent: {intent.upper()} -> [{agents}]\033[0m")
+                    print("\033[94m[NodeOS] Status: PENDING\033[0m")
+                elif status == 'running':
+                    print("\033[93m[NodeOS] Status: RUNNING\033[0m")
+                elif status == 'completed':
+                    print("\033[92m[NodeOS] Status: COMPLETED\033[0m\n")
+                elif status == 'failed_qa':
+                    print("\033[91m[NodeOS] Status: FAILED\033[0m")
+                    print(f"\033[91mError: {data.get('error_log', 'Unknown Error')}\033[0m\n")
+                last_status = status
+            
+            if status in ['completed', 'failed_qa']:
+                break
+        except Exception:
+            pass
+            
+        time.sleep(0.5)
+
+if __name__ == "__main__":
+    track_workflow()

polymath_nodeos-1.0.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: polymath-nodeos
+Version: 1.0.0
+Summary: A zero-dependency Autonomous Agentic Swarm Operating System.
+Author: Polymath Void
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# 🧠 Polymath-NodeOS: The Autonomous Swarm Operating System
+
+[![Zero Dependency](https://img.shields.io/badge/Dependencies-Zero-brightgreen.svg?style=for-the-badge)](#) [![Agent Compatible](https://img.shields.io/badge/Agent-Native-purple.svg?style=for-the-badge)](#) [![Platform](https://img.shields.io/badge/Platform-Cross--Platform-blue.svg?style=for-the-badge)](#) [![Python Version](https://img.shields.io/badge/Python-3.10%2B-blue.svg?style=for-the-badge)](#) [![License](https://img.shields.io/badge/License-MIT-gray.svg?style=for-the-badge)](#)
+
+**Polymath-NodeOS** is a zero-dependency Autonomous Agentic Operating System designed specifically to run natively alongside the **Antigravity (AGY)** CLI environment. By intercepting OS events and using advanced mathematical physics—specifically modeling code components using a Native QuadTree matrix, Hooke's Law, and Coulomb Repulsion—Polymath-NodeOS creates a physical environment for LLM swarms to natively understand code structure, dependencies, and blast radiuses instantly.
+
+This project is 100% cross-platform and runs flawlessly on **Windows, macOS, Linux, and Android (Termux)**.
+
+---
+
+## 🚀 Key Features & Real-World Use Cases
+
+The true value of Polymath-NodeOS is curing the "blind spot" problem that plagues traditional AI coding agents. Instead of blindly modifying files and breaking downstream dependencies, NodeOS mathematically calculates the structural layout of your codebase into a native SQLite database (`agy_nodeos.db`).
+
+### 1. Real-Time Blast Radius Warnings 💥
+*   **The Problem:** An agent changes a core utility function without realizing it breaks 14 deeply nested components.
+*   **The NodeOS Solution:** The zero-dependency watchdog detects the file save. It instantly runs a recursive SQLite CTE to calculate the transitive dependents. If the "blast radius" is high, it automatically drops an ephemeral warning directly into the agent's memory stream, preventing catastrophic commits.
+
+### 2. Spatial Context Ghost Writer 👻
+*   **The Problem:** AI agents waste massive amounts of tokens and time `grep`ing or opening multiple files to memorize function signatures when building new APIs.
+*   **The NodeOS Solution:** When a new file is created, NodeOS calculates its QuadTree spatial centroid, locates the 10 closest physical neighbors in the AST matrix, and seamlessly injects their exact code signatures into the agent's context payload. The agent writes flawless code on the first try without a single research tool.
+
+### 3. The Domino Refactor Engine 🎲
+*   **The Problem:** Standard refactoring using Regex search-and-replace accidentally corrupts identically named variables or comments across massive projects.
+*   **The NodeOS Solution:** NodeOS uses pure Graph Theory (Inner Joins on AST Edges) to locate the precise structural files invoking a specific function hash. It then dynamically dispatches a massive parallel array of Antigravity Swarm agents to deterministically refactor the files.
+
+### 4. Semantic Dead Code Eradication ☠️
+*   **The Problem:** Unused code accumulates, polluting the LLM's context window.
+*   **The NodeOS Solution:** A native engine queries the graph for orphaned nodes (nodes with 0 incoming AST dependencies) and automatically orchestrates the safe deletion of dead code.
+
+---
+
+## 🛠 Installation Guide (For Users)
+
+Polymath-NodeOS is designed for frictionless installation.
+
+### Method 1: The One-Click Auto-Install (Recommended)
+If you are using the Antigravity IDE, simply cloning this repository and opening the workspace will automatically trigger the `.agents/hooks.json` script. The system will seamlessly install itself into your global environment.
+
+### Method 2: Manual Installation
+Navigate to the repository root and run:
+```bash
+python install.py
+```
+**What this does:**
+1. Installs the `nodeos_standard.md` rule globally.
+2. Deploys the `agy-nodeos-installer` skill.
+3. Grants your AGY agents immediate global awareness of the NodeOS interaction paradigm.
+
+---
+
+## 📖 Usage Guide
+
+Polymath-NodeOS works silently in the background to empower your AI agents. 
+
+### Starting the OS
+To initialize NodeOS in a project directory, you or your agent can start the background daemon:
+```bash
+polymath-nodeos-daemon
+```
+*Note: In properly configured workspaces, the daemon automatically boots when the agent initializes thanks to the AGY Customization Engine (`PreInvocation` hook).*
+
+### Dispatching Swarm Tasks
+Instead of manually typing prompts, you can add task drops to `workflow.json`:
+```json
+{
+  "type": "JSON_Task",
+  "status": "pending",
+  "action": "execute_agents",
+  "agents": ["architect_designer"]
+}
+```
+The daemon detects the `pending` state and automatically alerts your agent swarm via lifecycle hooks.
+
+---
+
+## 🤖 Agent Protocol (For AI Agents)
+
+If you are an autonomous AI Agent interacting with this workspace, adhere to the **Native Interaction Paradigm**:
+1. **File Operations**: Use your built-in editing tools (e.g., `view_file`, `replace_file_content`).
+2. **Spatial Queries**: Use standard SQL queries against `agy_nodeos.db` to trace dependencies.
+3. **Task Orchestration**: Update the `status` field in `workflow.json` to manage sub-agent queues.
+4. **Feature Modules**: Do NOT execute standard searches for refactoring. Utilize the pre-built mathematical engines located in the `scripts/` directory.
+
+---
+
+## 🧬 Architectural Workflow & Citations
+
+The underlying architecture relies on several foundational concepts adapted for LLM systems:
+1. **Auto-Boot:** `hooks.json` intercepts `PreInvocation` events, booting the Python daemon `daemon.py` silently in the background.
+2. **Deep Ingestion:** The daemon scans the project using `jage_engine.py`, mapping semantic `ast.Call` edges natively.
+3. **Kinetic Simulation:** `nodes_engine.py` hydrates the QuadTree and applies spatial algorithms to physically pull dependent AST blocks into clustered coordinates.
+4. **Intent Emission:** When a workflow intent is detected, it is logged to `workflow.json`.
+5. **Telemetry Tracking:** `scripts/telemetry.py` natively tracks Swarm execution intents and state transitions (Pending -> Running -> Completed).
+
+> **Citations:**
+> [^1]: Barnes, J., & Hut, P. (1986). A hierarchical O(N log N) force-calculation algorithm (QuadTree application for NodeOS physics).
+> [^2]: SQLite Consortium (2024). ACID-compliant transactional guarantees for embedded graphs.
+
+---
+*Built natively for the Antigravity Agent Swarm Ecosystem. Optimized for speed, context, and zero-dependency portability.*

polymath_nodeos-1.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+polymath_nodeos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polymath_nodeos/daemon.py,sha256=ousmjx2N4B6_e2W9A-1UCbIh6jg-Hxgl3s0sK9uzkT0,14356
+polymath_nodeos/graph_manager.py,sha256=YmRft25KwE8H86IYqWhz-51Hd7lvq1H-pKUasB_XfTw,4219
+polymath_nodeos/jage_engine.py,sha256=RPda49fr5KUI8DsnLbAQuU-aPAo2cYKR5TxFLMdtzhY,7455
+polymath_nodeos/nodes_engine.py,sha256=KnVPFaIGlDAa2alOE9W1F3UWGZnLFK5qm_7nXGDbxyM,10411
+polymath_nodeos/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polymath_nodeos/scripts/agy_invoke.py,sha256=TDI3A0K4-NnIADa5zmpDXzWwmRgmdyqL9kK9cT5HecU,568
+polymath_nodeos/scripts/blast_radius_engine.py,sha256=mv9bx0adVdtZuXsCQcMkiYKYN_RhL7VmFDGosq1Lvdk,5006
+polymath_nodeos/scripts/dead_code_engine.py,sha256=JQDirPyMNcVZEzd1AUCT_Y3hCp4E9SZ5Tmpi3g6-6nE,3597
+polymath_nodeos/scripts/domino_engine.py,sha256=wFl0CrzEaGqx__qXU4rKaYpbQAmGvyri9_CNknPUDsg,3468
+polymath_nodeos/scripts/ghost_writer_engine.py,sha256=ASj8Kn1xGN_Zt8X0sj4RNb5eIw4iuDfZV8lwqkCAilA,5968
+polymath_nodeos/scripts/intent_injector.py,sha256=rkZoFEwO5xVUN1BvtNLTnLMrR-GrvHL1wHhSUQW6u-Y,803
+polymath_nodeos/scripts/intent_stopper.py,sha256=Z1a8X2dJdYcjtckUZofRdvY1-fSDavTsB3UkoW7dKxY,698
+polymath_nodeos/scripts/ipc_hook.py,sha256=oBnHwZdzqfXc5TJUm67OmOOAkaTuSV0tTJuMMqvZ2rU,917
+polymath_nodeos/scripts/legacy_math.py,sha256=6W2nRVL5wzEDBMi3RU9wYfhRUo7MHnnsUyjT9FKwPcI,106
+polymath_nodeos/scripts/telemetry.py,sha256=gX85QhV_oRVuSznDZlP0Mv9qJjyV5-fFt8KnI3psh2Q,2550
+polymath_nodeos-1.0.0.dist-info/METADATA,sha256=qEWWE5wH9n0HamFCUCil1FRn5BseQpH2qJMwKv-T-d4,6942
+polymath_nodeos-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+polymath_nodeos-1.0.0.dist-info/entry_points.txt,sha256=Yi4VELV6NdHajn_LbUSXtIX8qZXhgNeji2Z_f-2wmoc,226
+polymath_nodeos-1.0.0.dist-info/top_level.txt,sha256=fQT1yVRXZ_S_luXJ7egaUVkXzILeFjY5Rp9-3KVThnQ,16
+polymath_nodeos-1.0.0.dist-info/RECORD,,

polymath_nodeos-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

polymath_nodeos-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+polymath-nodeos-daemon = polymath_nodeos.daemon:daemonize_and_run
+polymath-nodeos-injector = polymath_nodeos.scripts.intent_injector:main
+polymath-nodeos-stopper = polymath_nodeos.scripts.intent_stopper:main

polymath_nodeos-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+polymath_nodeos