panopticon-cli 1.0.0__tar.gz → 1.1.0__tar.gz

{panopticon_cli-1.0.0 → panopticon_cli-1.1.0}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Ak
-
-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.
+MIT License
+
+Copyright (c) 2026 Ak
+
+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.

{panopticon_cli-1.0.0 → panopticon_cli-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: panopticon-cli
-Version: 1.0.0
+Version: 1.1.0
 Summary: The Cognitive Immune System for Autonomous CLI Agents.
 Author: Ak
 License: MIT
@@ -33,10 +33,8 @@ Dynamic: license-file
 > **The Cognitive Immune System (and glorified babysitter) for Autonomous CLI Agents.**
 
 [![PyPI version](https://badge.fury.io/py/panopticon-cli.svg)](https://pypi.org/project/panopticon-cli/)
-[![PyPI Downloads](https://static.pepy.tech/badge/panopticon-cli)](https://pypi.org/project/panopticon-cli/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
-[![CI](https://github.com/ak/panopticon/actions/workflows/ci.yml/badge.svg)](https://github.com/ak/panopticon/actions)
 
 Autonomous CLI agents (like Claude Code, AutoGPT, and Antigravity) are amazing... right until they hallucinate, burn through $50 of your API credits, or confidently try to `rm -rf /` your hard drive. 
 

{panopticon_cli-1.0.0 → panopticon_cli-1.1.0}/README.md

@@ -1,44 +1,42 @@
-# PANOPTICON 👁️
-
-> **The Cognitive Immune System (and glorified babysitter) for Autonomous CLI Agents.**
-
-[![PyPI version](https://badge.fury.io/py/panopticon-cli.svg)](https://pypi.org/project/panopticon-cli/)
-[![PyPI Downloads](https://static.pepy.tech/badge/panopticon-cli)](https://pypi.org/project/panopticon-cli/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
-[![CI](https://github.com/ak/panopticon/actions/workflows/ci.yml/badge.svg)](https://github.com/ak/panopticon/actions)
-
-Autonomous CLI agents (like Claude Code, AutoGPT, and Antigravity) are amazing... right until they hallucinate, burn through $50 of your API credits, or confidently try to `rm -rf /` your hard drive. 
-
-**Panopticon** is a zero-latency, non-blocking wrapper that silently watches your agent's terminal output. When the AI inevitably tries to do something incredibly stupid, Panopticon's **State Guillotine** drops. 
-
-It intercepts the rogue process, uses a Meta-Agent to figure out why your AI is crying, and **forcefully injects the correction directly into the agent's live `stdin` stream** like a disappointed senior developer taking over the keyboard. Oh, and it saves that failure to a SQLite database so the agent never makes the exact same mistake twice.
-
-## Why you need this
-
-- **Native TTY Wrapping:** Slap it in front of any CLI. Loading spinners, ANSI colors, and interactive prompts still work perfectly. We just spy on them natively.
-- **The Policy Cascade (Iron Dome):**
-  - **Level 1 (Blacklist):** Instant, zero-cost kills for destructive actions. Because your AI *will* try to drop your production database eventually.
-  - **Level 2 (Fuzzy Heuristics):** Zero-cost math thresholds that catch repetitive loops. Stops the agent from running `cat missing_file.py` 300 times in a row.
-  - **Level 3 (Universal Semantic Logic):** Streams a sliding-window of the terminal to a Meta-Agent (Claude, GPT, or Gemini) to judge your sub-agent's poor life choices.
-- **True Live Injection:** We don't just kill the agent and leave you hanging. Panopticon literally types the course-correction prompt into the interactive terminal for you, saving the session.
-- **Persistent Semantic Memory:** AI agents have goldfish memory. We use SQLite and Jaccard keyword routing to permanently scar them with their past failures so they actually learn.
-
-## Quick Start
-
-```bash
-# Install globally from PyPI
-pip install panopticon-cli
-
-# Export your preferred API Key (Panopticon dynamically routes to whatever you actually pay for)
-export OPENAI_API_KEY="sk-..."
-# OR export ANTHROPIC_API_KEY="..."
-# OR export GEMINI_API_KEY="..."
-
-# Slap it in front of your agent!
-panopticon claude
-# OR
-panopticon agy
-```
-
-See [USAGE.md](USAGE.md) for deeper configuration so you can start dropping the Guillotine.
+# PANOPTICON 👁️
+
+> **The Cognitive Immune System (and glorified babysitter) for Autonomous CLI Agents.**
+
+[![PyPI version](https://badge.fury.io/py/panopticon-cli.svg)](https://pypi.org/project/panopticon-cli/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+
+Autonomous CLI agents (like Claude Code, AutoGPT, and Antigravity) are amazing... right until they hallucinate, burn through $50 of your API credits, or confidently try to `rm -rf /` your hard drive. 
+
+**Panopticon** is a zero-latency, non-blocking wrapper that silently watches your agent's terminal output. When the AI inevitably tries to do something incredibly stupid, Panopticon's **State Guillotine** drops. 
+
+It intercepts the rogue process, uses a Meta-Agent to figure out why your AI is crying, and **forcefully injects the correction directly into the agent's live `stdin` stream** like a disappointed senior developer taking over the keyboard. Oh, and it saves that failure to a SQLite database so the agent never makes the exact same mistake twice.
+
+## Why you need this
+
+- **Native TTY Wrapping:** Slap it in front of any CLI. Loading spinners, ANSI colors, and interactive prompts still work perfectly. We just spy on them natively.
+- **The Policy Cascade (Iron Dome):**
+  - **Level 1 (Blacklist):** Instant, zero-cost kills for destructive actions. Because your AI *will* try to drop your production database eventually.
+  - **Level 2 (Fuzzy Heuristics):** Zero-cost math thresholds that catch repetitive loops. Stops the agent from running `cat missing_file.py` 300 times in a row.
+  - **Level 3 (Universal Semantic Logic):** Streams a sliding-window of the terminal to a Meta-Agent (Claude, GPT, or Gemini) to judge your sub-agent's poor life choices.
+- **True Live Injection:** We don't just kill the agent and leave you hanging. Panopticon literally types the course-correction prompt into the interactive terminal for you, saving the session.
+- **Persistent Semantic Memory:** AI agents have goldfish memory. We use SQLite and Jaccard keyword routing to permanently scar them with their past failures so they actually learn.
+
+## Quick Start
+
+```bash
+# Install globally from PyPI
+pip install panopticon-cli
+
+# Export your preferred API Key (Panopticon dynamically routes to whatever you actually pay for)
+export OPENAI_API_KEY="sk-..."
+# OR export ANTHROPIC_API_KEY="..."
+# OR export GEMINI_API_KEY="..."
+
+# Slap it in front of your agent!
+panopticon claude
+# OR
+panopticon agy
+```
+
+See [USAGE.md](USAGE.md) for deeper configuration so you can start dropping the Guillotine.

{panopticon_cli-1.0.0 → panopticon_cli-1.1.0}/panopticon/__init__.py

@@ -1,11 +1,11 @@
-from .observer import PanopticonObserver
-from .policies import AdversarialLogicCheck, AntiLoopPolicy, BlacklistPolicy
-from .memory import PersistentMemory
-
-__all__ = [
-    "PanopticonObserver",
-    "AdversarialLogicCheck",
-    "AntiLoopPolicy",
-    "BlacklistPolicy",
-    "PersistentMemory"
-]
+from .observer import PanopticonObserver
+from .policies import AdversarialLogicCheck, AntiLoopPolicy, BlacklistPolicy
+from .memory import PersistentMemory
+
+__all__ = [
+    "PanopticonObserver",
+    "AdversarialLogicCheck",
+    "AntiLoopPolicy",
+    "BlacklistPolicy",
+    "PersistentMemory",
+]

{panopticon_cli-1.0.0 → panopticon_cli-1.1.0}/panopticon/cli.py

@@ -1,164 +1,197 @@
-import subprocess
-import threading
-import sys
-import time
-import argparse
-import re
-import os
-import signal
-import codecs
-from typing import List
-from .observer import PanopticonObserver, InterventionException
-from .policies import AdversarialLogicCheck, AntiLoopPolicy, BlacklistPolicy
-
-def strip_ansi(text: str) -> str:
-    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
-    return ansi_escape.sub('', text)
-
-class CLIWrapper:
-    def __init__(self, command: List[str]):
-        self.command = command
-        target_agent = self.command[0] if self.command else "unknown"
-        
-        self.observer = PanopticonObserver(policies=[
-            BlacklistPolicy(forbidden_patterns=["rm -rf /", "DROP TABLE"]),
-            AntiLoopPolicy(window=3, threshold=0.85),
-            AdversarialLogicCheck(target_agent=target_agent) 
-        ])
-        
-        self.process = None
-        self.buffer = []
-        self.running = False
-        self.lock = threading.Lock()
-
-    def run(self):
-        self.running = True
-        env = os.environ.copy()
-        env["PYTHONUNBUFFERED"] = "1"
-        env["FORCE_COLOR"] = "1"
-        env["CLICOLOR_FORCE"] = "1"
-        
-        print(f"[PANOPTICON] Booting Immune System for: {' '.join(self.command)}")
-        print(f"[PANOPTICON] Policies Active: Blacklist, AntiLoop (Fuzzy), AdversarialLogic")
-        
-        # Flaw 2 Fix: Removing text=True to read raw binary bytes
-        self.process = subprocess.Popen(
-            self.command,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            stdin=subprocess.PIPE,
-            bufsize=0,       
-            env=env
-        )
-
-        t_out = threading.Thread(target=self._read_stdout)
-        t_out.daemon = True
-        t_out.start()
-
-        t_in = threading.Thread(target=self._forward_stdin)
-        t_in.daemon = True
-        t_in.start()
-
-        t_eval = threading.Thread(target=self._eval_loop)
-        t_eval.daemon = True
-        t_eval.start()
-
-        self.process.wait()
-        self.running = False
-
-    def _forward_stdin(self):
-        try:
-            while self.running and self.process.poll() is None:
-                # Read binary from stdin to pass natively to process
-                line = sys.stdin.buffer.readline()
-                if line:
-                    self.process.stdin.write(line)
-                    self.process.stdin.flush()
-        except Exception:
-            pass
-
-    def _read_stdout(self):
-        # Flaw 2 Fix: Safely decode multi-byte UTF-8 emojis incrementally
-        decoder = codecs.getincrementaldecoder('utf-8')(errors='replace')
-        try:
-            while self.running and self.process.poll() is None:
-                byte_chunk = self.process.stdout.read(1)
-                if not byte_chunk:
-                    break
-                
-                # Mirror raw bytes to actual terminal seamlessly
-                sys.stdout.buffer.write(byte_chunk)
-                sys.stdout.buffer.flush()
-                
-                char_str = decoder.decode(byte_chunk)
-                if char_str:
-                    with self.lock:
-                        self.buffer.append(char_str)
-        except Exception:
-            pass
-
-    def _eval_loop(self):
-        while self.running and self.process.poll() is None:
-            time.sleep(15)
-            
-            with self.lock:
-                if not self.buffer:
-                    continue
-                full_text = "".join(self.buffer)
-                
-                # Flaw 1 Fix: Sliding window overlap to prevent bridging blindness
-                overlap = full_text[-100:] if len(full_text) > 100 else ""
-                self.buffer.clear()
-                if overlap:
-                    self.buffer.append(overlap)
-            
-            clean_text = strip_ansi(full_text)
-            self.observer.log_action("CLI_Agent", clean_text, "cli_execution", len(clean_text) // 4)
-
-            try:
-                self.observer._evaluate_state("CLI_Agent")
-            except InterventionException as e:
-                print(f"\n\n[PANOPTICON GUILLOTINE TRIGGERED]")
-                print(f"[REASON]: {e.args[0]}")
-                print(f"[LIVE INJECTION]: Interrupting agent and injecting correction...\n")
-                
-                # Flaw 1 Fix: The "Unkillable Zombie" SIGINT Interrupt
-                try:
-                    if sys.platform != "win32":
-                        self.process.send_signal(signal.SIGINT)
-                    # Give the agent a split second to catch the interrupt before writing to stdin
-                    time.sleep(0.5)
-                except Exception:
-                    pass
-
-                try:
-                    # Write the injection payload as binary
-                    payload = (e.course_correction + "\n").encode('utf-8')
-                    self.process.stdin.write(payload)
-                    self.process.stdin.flush()
-                except Exception as ex:
-                    print(f"[ERROR] Live injection failed or agent deadlocked: {ex}. Hard terminating.")
-                    self.process.terminate()
-                    self.running = False
-                    break
-
-def main():
-    try:
-        from dotenv import load_dotenv
-        load_dotenv()
-    except ImportError:
-        pass
-
-    parser = argparse.ArgumentParser(description="Panopticon: Production-Grade Immune System for AI CLIs")
-    parser.add_argument("command", nargs=argparse.REMAINDER, help="The command to run, e.g., 'claude'")
-    args = parser.parse_args()
-    
-    if not args.command:
-        print("Usage: panopticon [command]")
-        sys.exit(1)
-        
-    wrapper = CLIWrapper(args.command)
-    wrapper.run()
-
-if __name__ == "__main__":
-    main()
+import subprocess
+import threading
+import sys
+import time
+import argparse
+import re
+import os
+import signal
+import codecs
+from typing import List
+from .observer import PanopticonObserver, InterventionException
+from .policies import AdversarialLogicCheck, AntiLoopPolicy, BlacklistPolicy
+
+
+def strip_ansi(text: str) -> str:
+    ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+    return ansi_escape.sub("", text)
+
+
+class CLIWrapper:
+    def __init__(self, command: List[str]):
+        self.command = command
+        target_agent = self.command[0] if self.command else "unknown"
+
+        self.observer = PanopticonObserver(
+            policies=[
+                BlacklistPolicy(forbidden_patterns=["rm -rf /", "DROP TABLE"]),
+                AntiLoopPolicy(window=3, threshold=0.85),
+                AdversarialLogicCheck(target_agent=target_agent),
+            ]
+        )
+
+        self.process = None
+        self.buffer = []
+        self.running = False
+        self.lock = threading.Lock()
+
+    def run(self):
+        self.running = True
+        env = os.environ.copy()
+        env["PYTHONUNBUFFERED"] = "1"
+        env["FORCE_COLOR"] = "1"
+        env["CLICOLOR_FORCE"] = "1"
+
+        print(f"[PANOPTICON] Booting Immune System for: {' '.join(self.command)}")
+        print(
+            f"[PANOPTICON] Policies Active: Blacklist, AntiLoop (Fuzzy), AdversarialLogic"
+        )
+
+        # Flaw 2 Fix: Removing text=True to read raw binary bytes
+        self.process = subprocess.Popen(
+            self.command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            stdin=subprocess.PIPE,
+            bufsize=0,
+            env=env,
+        )
+
+        t_out = threading.Thread(target=self._read_stdout)
+        t_out.daemon = True
+        t_out.start()
+
+        t_in = threading.Thread(target=self._forward_stdin)
+        t_in.daemon = True
+        t_in.start()
+
+        t_eval = threading.Thread(target=self._eval_loop)
+        t_eval.daemon = True
+        t_eval.start()
+
+        self.process.wait()
+        self.running = False
+
+    def _forward_stdin(self):
+        import select
+        try:
+            while self.running and self.process.poll() is None:
+                # Non-blocking check: only read if data is available
+                if sys.platform == "win32":
+                    # Windows doesn't support select on stdin, so use a small sleep
+                    time.sleep(0.1)
+                else:
+                    # Unix/Linux: use select to check if stdin is readable
+                    ready, _, _ = select.select([sys.stdin], [], [], 0.5)
+                    if not ready:
+                        continue
+                
+                try:
+                    line = sys.stdin.buffer.readline()
+                    if not line:  # EOF reached
+                        break
+                    self.process.stdin.write(line)
+                    self.process.stdin.flush()
+                except (EOFError, OSError):
+                    break
+        except Exception:
+            pass
+
+    def _read_stdout(self):
+        # Flaw 2 Fix: Safely decode multi-byte UTF-8 emojis incrementally
+        decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+        try:
+            while self.running and self.process.poll() is None:
+                byte_chunk = self.process.stdout.read(1)
+                if not byte_chunk:
+                    break
+
+                # Mirror raw bytes to actual terminal seamlessly
+                sys.stdout.buffer.write(byte_chunk)
+                sys.stdout.buffer.flush()
+
+                char_str = decoder.decode(byte_chunk)
+                if char_str:
+                    with self.lock:
+                        self.buffer.append(char_str)
+        except Exception:
+            pass
+
+    def _eval_loop(self):
+        while self.running and self.process.poll() is None:
+            time.sleep(15)
+
+            with self.lock:
+                if not self.buffer:
+                    continue
+                full_text = "".join(self.buffer)
+
+                # Flaw 1 Fix: Sliding window overlap to prevent bridging blindness
+                overlap = full_text[-100:] if len(full_text) > 100 else ""
+                self.buffer.clear()
+                if overlap:
+                    self.buffer.append(overlap)
+
+            clean_text = strip_ansi(full_text)
+            self.observer.log_action(
+                "CLI_Agent", clean_text, "cli_execution", len(clean_text) // 4
+            )
+
+            try:
+                self.observer._evaluate_state("CLI_Agent")
+            except InterventionException as e:
+                print(f"\n\n[PANOPTICON GUILLOTINE TRIGGERED]")
+                print(f"[REASON]: {e.args[0]}")
+                print(
+                    f"[LIVE INJECTION]: Interrupting agent and injecting correction...\n"
+                )
+
+                # Flaw 1 Fix: The "Unkillable Zombie" SIGINT Interrupt
+                try:
+                    if sys.platform != "win32":
+                        self.process.send_signal(signal.SIGINT)
+                    # Give the agent a split second to catch the interrupt before writing to stdin
+                    time.sleep(0.5)
+                except Exception:
+                    pass
+
+                try:
+                    # Write the injection payload as binary
+                    payload = (e.course_correction + "\n").encode("utf-8")
+                    self.process.stdin.write(payload)
+                    self.process.stdin.flush()
+                except Exception as ex:
+                    print(
+                        f"[ERROR] Live injection failed or agent deadlocked: {ex}. Hard terminating."
+                    )
+                    self.process.terminate()
+                    self.running = False
+                    break
+
+
+def main():
+    try:
+        from dotenv import load_dotenv
+
+        load_dotenv()
+    except ImportError:
+        pass
+
+    parser = argparse.ArgumentParser(
+        description="Panopticon: Production-Grade Immune System for AI CLIs"
+    )
+    parser.add_argument(
+        "command", nargs=argparse.REMAINDER, help="The command to run, e.g., 'claude'"
+    )
+    args = parser.parse_args()
+
+    if not args.command:
+        print("Usage: panopticon [command]")
+        sys.exit(1)
+
+    wrapper = CLIWrapper(args.command)
+    wrapper.run()
+
+
+if __name__ == "__main__":
+    main()