diogenesis-sdk 0.1.0__tar.gz

diogenesis_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Garry Anderson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

diogenesis_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: diogenesis-sdk
+Version: 0.1.0
+Summary: Behavioral health for Python applications. Not signatures. Not rules. Coherence.
+Author-email: Garry Anderson <prnt3dman1@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/prnt3dman1/diogenesis-sdk
+Keywords: security,behavioral,monitoring,runtime,anomaly,detection
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Diogenesis SDK
+
+**Behavioral health for Python applications.**
+
+Not signature-based detection. Not rule-based blocking. Behavioral coherence.
+
+## Install
+
+```
+pip install diogenesis-sdk
+```
+
+## Quick Start
+
+```python
+import diogenesis_sdk
+
+diogenesis_sdk.activate()
+# your application runs normally — every import, file access,
+# subprocess call, and network request is observed
+
+print(diogenesis_sdk.status())    # what's being tracked
+print(diogenesis_sdk.log(10))     # last 10 events
+print(diogenesis_sdk.baseline())  # behavioral fingerprint (after 1000+ events)
+
+diogenesis_sdk.deactivate()       # cleanly restore all originals
+```
+
+## What It Does
+
+Diogenesis intercepts every import, file access, subprocess call, and network request in your Python application. It classifies each as KNOWN, UNEXPECTED, or SUSPICIOUS based on behavioral patterns. After observing 1000+ events, it generates a behavioral baseline that defines what "normal" looks like. Deviations are anomalies — whether from attacks, bugs, or dependency rot.
+
+## Zero Dependencies
+
+Diogenesis uses only the Python standard library. A security product with supply chain risk is a contradiction.
+
+## Philosophy
+
+Inspired by Michael Levin's xenobot research: biological systems maintain health through behavioral coherence, not programmed rules. Diogenesis applies the same principle to software.
+
+## Design Principles
+
+- **Never break the host application.** Every interceptor is try/except wrapped. If Diogenesis fails, your code runs normally.
+- **Shadow mode only.** Diogenesis observes. It does not block. Policy enforcement comes in future versions.
+- **Zero dependencies.** stdlib only. No supply chain risk.
+- **Clean activate/deactivate.** One function call to start. One to stop. All originals restored.
+
+## Configuration
+
+Pass a config dict to `activate()`:
+
+```python
+diogenesis_sdk.activate({
+    "buffer_size": 5000,
+    "interceptors": {"import": True, "file": True, "subprocess": False, "network": True},
+    "whitelist": {
+        "import_modules": ["myapp", "mylib"],
+        "file_paths": ["/app/data/"],
+        "network_hosts": ["localhost", "api.myservice.com"],
+    },
+    "suspicious_patterns": {
+        "imports": ["ctypes"],
+        "subprocess_commands": ["rm -rf"],
+    },
+})
+```
+
+Or place a `diogenesis_sdk.json` file in your working directory.
+
+## License
+
+MIT

diogenesis_sdk-0.1.0/README.md

@@ -0,0 +1,72 @@
+# Diogenesis SDK
+
+**Behavioral health for Python applications.**
+
+Not signature-based detection. Not rule-based blocking. Behavioral coherence.
+
+## Install
+
+```
+pip install diogenesis-sdk
+```
+
+## Quick Start
+
+```python
+import diogenesis_sdk
+
+diogenesis_sdk.activate()
+# your application runs normally — every import, file access,
+# subprocess call, and network request is observed
+
+print(diogenesis_sdk.status())    # what's being tracked
+print(diogenesis_sdk.log(10))     # last 10 events
+print(diogenesis_sdk.baseline())  # behavioral fingerprint (after 1000+ events)
+
+diogenesis_sdk.deactivate()       # cleanly restore all originals
+```
+
+## What It Does
+
+Diogenesis intercepts every import, file access, subprocess call, and network request in your Python application. It classifies each as KNOWN, UNEXPECTED, or SUSPICIOUS based on behavioral patterns. After observing 1000+ events, it generates a behavioral baseline that defines what "normal" looks like. Deviations are anomalies — whether from attacks, bugs, or dependency rot.
+
+## Zero Dependencies
+
+Diogenesis uses only the Python standard library. A security product with supply chain risk is a contradiction.
+
+## Philosophy
+
+Inspired by Michael Levin's xenobot research: biological systems maintain health through behavioral coherence, not programmed rules. Diogenesis applies the same principle to software.
+
+## Design Principles
+
+- **Never break the host application.** Every interceptor is try/except wrapped. If Diogenesis fails, your code runs normally.
+- **Shadow mode only.** Diogenesis observes. It does not block. Policy enforcement comes in future versions.
+- **Zero dependencies.** stdlib only. No supply chain risk.
+- **Clean activate/deactivate.** One function call to start. One to stop. All originals restored.
+
+## Configuration
+
+Pass a config dict to `activate()`:
+
+```python
+diogenesis_sdk.activate({
+    "buffer_size": 5000,
+    "interceptors": {"import": True, "file": True, "subprocess": False, "network": True},
+    "whitelist": {
+        "import_modules": ["myapp", "mylib"],
+        "file_paths": ["/app/data/"],
+        "network_hosts": ["localhost", "api.myservice.com"],
+    },
+    "suspicious_patterns": {
+        "imports": ["ctypes"],
+        "subprocess_commands": ["rm -rf"],
+    },
+})
+```
+
+Or place a `diogenesis_sdk.json` file in your working directory.
+
+## License
+
+MIT

diogenesis_sdk-0.1.0/diogenesis_sdk/__init__.py

@@ -0,0 +1,52 @@
+"""Diogenesis SDK — Behavioral health for Python applications.
+
+Not signature-based detection. Not rule-based blocking. Behavioral coherence.
+
+Usage:
+    import diogenesis_sdk
+
+    diogenesis_sdk.activate()
+    print(diogenesis_sdk.status())            # interceptor counts + field coherence
+    print(diogenesis_sdk.field_state())       # per-module voltage map
+    print(diogenesis_sdk.alerts())            # policy alerts
+    print(diogenesis_sdk.investigations())    # xenobot findings
+    print(diogenesis_sdk.threat_summary())    # threat/suspicious/benign counts
+    diogenesis_sdk.deactivate()
+"""
+
+from .engine import DiogenesisEngine
+from .policy.pattern import BehavioralPattern
+from .timing.fibonacci import FibonacciClock
+from .agents.xenobot import XenobotAgent
+
+_engine = DiogenesisEngine()
+
+activate = _engine.activate
+deactivate = _engine.deactivate
+status = _engine.status
+log = _engine.log
+baseline = _engine.baseline
+configure = _engine.configure
+alerts = _engine.alerts
+alert_summary = _engine.alert_summary
+escalations = _engine.escalations
+add_pattern = _engine.add_pattern
+evaluate_policies = _engine.evaluate_policies
+field_state = _engine.field_state
+module_voltage = _engine.module_voltage
+voltage_history = _engine.voltage_history
+connection_graph = _engine.connection_graph
+create_scheduler = _engine.create_scheduler
+investigations = _engine.investigations
+threat_summary = _engine.threat_summary
+add_agent = _engine.add_agent
+
+__version__ = "0.1.0"
+__author__ = "Garry Anderson"
+__all__ = [
+    "activate", "deactivate", "status", "log", "baseline", "configure",
+    "alerts", "alert_summary", "escalations", "add_pattern", "evaluate_policies",
+    "field_state", "module_voltage", "voltage_history", "connection_graph",
+    "create_scheduler", "investigations", "threat_summary", "add_agent",
+    "BehavioralPattern", "FibonacciClock", "XenobotAgent",
+]

diogenesis_sdk-0.1.0/diogenesis_sdk/agents/swarm.py

@@ -0,0 +1,152 @@
+"""Xenobot swarm — coordinate multiple autonomous investigation agents."""
+
+import os
+from collections import deque
+
+from .xenobot import XenobotAgent, Investigation
+
+
+class XenobotSwarm:
+    """Coordinate multiple xenobot agents. Each specializes in a domain."""
+
+    def __init__(self):
+        self.agents = {}
+        self.investigation_log = deque(maxlen=2000)
+        self.shared_model = {}
+
+    def create_default_swarm(self):
+        """Create the standard 4-agent swarm."""
+        self.agents = {
+            "import_guardian": XenobotAgent("import_guardian", domain="import"),
+            "file_sentinel": XenobotAgent("file_sentinel", domain="file"),
+            "network_watcher": XenobotAgent("network_watcher", domain="network"),
+            "subprocess_monitor": XenobotAgent("subprocess_monitor", domain="subprocess"),
+        }
+
+    def add_agent(self, agent):
+        """Add a custom agent to the swarm."""
+        self.agents[agent.name] = agent
+
+    def remove_agent(self, name):
+        """Remove an agent by name."""
+        self.agents.pop(name, None)
+
+    def respond_to_alert(self, alert, context) -> list:
+        """Dispatch appropriate agent(s) to investigate an alert."""
+        results = []
+        matched_events = alert.get("matched_events", [])
+        event_types = set()
+        for evt in matched_events:
+            event_types.add(evt.get("type", "unknown"))
+
+        # Find agents whose domain matches any event type in the alert
+        dispatched = set()
+        for etype in event_types:
+            for name, agent in self.agents.items():
+                if agent.domain == etype and name not in dispatched:
+                    dispatched.add(name)
+                    # Use the first event of this agent's domain as trigger
+                    trigger = next((e for e in matched_events if e.get("type") == etype), matched_events[0])
+                    inv = agent.investigate(trigger, context)
+                    self.investigation_log.append(inv)
+                    results.append(inv)
+
+        # If no domain-specific agent matched, use first available agent
+        if not results and self.agents and matched_events:
+            agent = next(iter(self.agents.values()))
+            inv = agent.investigate(matched_events[0], context)
+            self.investigation_log.append(inv)
+            results.append(inv)
+
+        return results
+
+    def respond_to_voltage_drop(self, module_name, voltage, context) -> Investigation:
+        """Investigate a module with dangerously low voltage."""
+        # Determine the module's primary event type from recent events
+        recent = context.get("recent_events", [])
+        module_events = [e for e in recent if module_name in str(e.get("caller_file", ""))]
+
+        # Count event types for this module
+        type_counts = {}
+        for e in module_events[-50:]:
+            t = e.get("type", "unknown")
+            type_counts[t] = type_counts.get(t, 0) + 1
+
+        primary_type = max(type_counts, key=type_counts.get) if type_counts else "unknown"
+
+        # Find the right agent
+        agent = None
+        for a in self.agents.values():
+            if a.domain == primary_type:
+                agent = a
+                break
+        if agent is None and self.agents:
+            agent = next(iter(self.agents.values()))
+        if agent is None:
+            inv = Investigation()
+            inv.agent_name = "none"
+            inv.verdict = "SUSPICIOUS"
+            inv.reasoning = "No agents available"
+            return inv
+
+        # Create a synthetic trigger for the voltage drop
+        trigger = {
+            "type": primary_type,
+            "classification": "UNEXPECTED",
+            "caller_file": f"{module_name}.py",
+            "detail": {"voltage_drop": True, "voltage": voltage, "module": module_name},
+        }
+        inv = agent.investigate(trigger, context)
+        self.investigation_log.append(inv)
+        return inv
+
+    def get_findings(self, n=50, verdict=None) -> list:
+        """Return recent findings, optionally filtered by verdict."""
+        items = list(self.investigation_log)
+        if verdict:
+            items = [i for i in items if i.verdict == verdict]
+        return [i.to_dict() if hasattr(i, "to_dict") else i for i in items[-n:]]
+
+    def get_threat_summary(self) -> dict:
+        """Count of threats, suspicious, benign across the swarm."""
+        items = list(self.investigation_log)
+        counts = {"THREAT": 0, "SUSPICIOUS": 0, "BENIGN": 0}
+        for inv in items:
+            v = inv.verdict if hasattr(inv, "verdict") else "UNKNOWN"
+            counts[v] = counts.get(v, 0) + 1
+
+        agent_stats = {}
+        for name, agent in self.agents.items():
+            agent_stats[name] = dict(agent.stats)
+
+        return {
+            "threats": counts.get("THREAT", 0),
+            "suspicious": counts.get("SUSPICIOUS", 0),
+            "benign": counts.get("BENIGN", 0),
+            "total_investigations": len(items),
+            "agents": agent_stats,
+        }
+
+    def share_learning(self):
+        """Sync behavioral models across all agents.
+
+        When one agent learns a pattern is BENIGN, all agents learn it.
+        When one agent identifies a THREAT pattern, all agents watch for it.
+        """
+        # Merge all agent models into shared model
+        for agent in self.agents.values():
+            for phash, entry in agent.behavioral_model.items():
+                existing = self.shared_model.get(phash)
+                if existing is None or entry["last_seen"] > existing["last_seen"]:
+                    self.shared_model[phash] = dict(entry)
+
+        # Distribute shared model back to all agents
+        for agent in self.agents.values():
+            for phash, entry in self.shared_model.items():
+                if phash not in agent.behavioral_model:
+                    agent.behavioral_model[phash] = dict(entry)
+                else:
+                    existing = agent.behavioral_model[phash]
+                    if entry["last_seen"] > existing["last_seen"]:
+                        existing["verdict"] = entry["verdict"]
+                        existing["last_seen"] = entry["last_seen"]