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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: panopticon-cli
-Version: 1.1.0
+Version: 1.1.2
 Summary: The Cognitive Immune System for Autonomous CLI Agents.
 Author: Ak
 License: MIT
@@ -34,6 +34,7 @@ Dynamic: license-file
 
 [![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)
+[![CI](https://github.com/ak495867/Panopticon/actions/workflows/ci.yml/badge.svg)](https://github.com/ak495867/Panopticon/actions/workflows/ci.yml)
 [![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_cli-1.1.0 → panopticon_cli-1.1.2}/README.md

@@ -4,6 +4,7 @@
 
 [![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)
+[![CI](https://github.com/ak495867/Panopticon/actions/workflows/ci.yml/badge.svg)](https://github.com/ak495867/Panopticon/actions/workflows/ci.yml)
 [![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_cli-1.1.2/panopticon/cli.py

@@ -0,0 +1,267 @@
+import subprocess
+import threading
+import sys
+import time
+import argparse
+import re
+import os
+import signal
+import codecs
+import atexit
+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()
+        self.threads = []
+        self.stdin_reader = None
+
+    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), "
+            f"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, daemon=True)
+        t_out.start()
+        self.threads.append(t_out)
+
+        t_eval = threading.Thread(target=self._eval_loop, daemon=True)
+        t_eval.start()
+        self.threads.append(t_eval)
+
+        t_in = threading.Thread(target=self._read_stdin, daemon=True)
+        t_in.start()
+        self.threads.append(t_in)
+
+        # Register cleanup on exit
+        atexit.register(self._cleanup)
+
+        try:
+            self.process.wait()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self.running = False
+            self._cleanup()
+
+    def _cleanup(self):
+        """Cleanly shutdown all threads and resources."""
+        self.running = False
+
+        # Close subprocess pipes FIRST before thread cleanup
+        if self.process:
+            try:
+                if self.process.stdin and not self.process.stdin.closed:
+                    self.process.stdin.close()
+            except Exception:
+                pass
+
+            try:
+                if self.process.stdout and not self.process.stdout.closed:
+                    self.process.stdout.close()
+            except Exception:
+                pass
+
+            try:
+                if self.process.poll() is None:
+                    self.process.terminate()
+                    try:
+                        self.process.wait(timeout=2)
+                    except subprocess.TimeoutExpired:
+                        self.process.kill()
+            except Exception:
+                pass
+
+        # Wait for threads with timeout
+        for thread in self.threads:
+            if thread.is_alive():
+                thread.join(timeout=1)
+
+    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 and self.process.poll() is None:
+                try:
+                    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 (OSError, ValueError, BrokenPipeError):
+                    break
+        except Exception:
+            pass
+        finally:
+            try:
+                if (
+                    self.process
+                    and self.process.stdout
+                    and (not self.process.stdout.closed)
+                ):
+                    self.process.stdout.close()
+            except Exception:
+                pass
+
+    def _read_stdin(self):
+        try:
+            while self.running and self.process and self.process.poll() is None:
+                try:
+                    data = sys.stdin.buffer.read1(1024)
+                    if not data:
+                        break
+                    if self.process.stdin and not self.process.stdin.closed:
+                        self.process.stdin.write(data)
+                        self.process.stdin.flush()
+                except (OSError, ValueError, BrokenPipeError):
+                    break
+        except Exception:
+            pass
+        finally:
+            try:
+                if (
+                    self.process
+                    and self.process.stdin
+                    and (not self.process.stdin.closed)
+                ):
+                    self.process.stdin.close()
+            except Exception:
+                pass
+
+    def _eval_loop(self):
+        while self.running and self.process 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 "
+                    f"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
+                    time.sleep(0.5)
+                except Exception:
+                    pass
+
+                try:
+                    # Write the injection payload as binary
+                    if self.process.stdin and not self.process.stdin.closed:
+                        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: "
+                        f"{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)
+    try:
+        wrapper.run()
+    except KeyboardInterrupt:
+        print("\n[PANOPTICON] Interrupted by user. Cleaning up...")
+        wrapper._cleanup()
+        sys.exit(0)
+    except Exception as e:
+        print(f"[PANOPTICON ERROR] {e}")
+        wrapper._cleanup()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

{panopticon_cli-1.1.0 → panopticon_cli-1.1.2}/panopticon_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: panopticon-cli
-Version: 1.1.0
+Version: 1.1.2
 Summary: The Cognitive Immune System for Autonomous CLI Agents.
 Author: Ak
 License: MIT
@@ -34,6 +34,7 @@ Dynamic: license-file
 
 [![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)
+[![CI](https://github.com/ak495867/Panopticon/actions/workflows/ci.yml/badge.svg)](https://github.com/ak495867/Panopticon/actions/workflows/ci.yml)
 [![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_cli-1.1.0 → panopticon_cli-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "panopticon-cli"
-version = "1.1.0"
+version = "1.1.2"
 description = "The Cognitive Immune System for Autonomous CLI Agents."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -41,3 +41,7 @@ dev = [
 
 [project.scripts]
 panopticon = "panopticon.cli:main"
+
+[tool.black]
+target_version = ["py39", "py310", "py311", "py312"]
+line_length = 88

panopticon_cli-1.1.2/tests/test_cli.py

@@ -0,0 +1,63 @@
+import io
+import sys
+
+from panopticon.cli import CLIWrapper, strip_ansi
+
+
+class DummyStdinStream:
+    def __init__(self, data: bytes):
+        self.buffer = io.BytesIO(data)
+
+
+class DummyProcessStdin:
+    def __init__(self):
+        self.written = bytearray()
+        self.closed = False
+
+    def write(self, data: bytes):
+        self.written.extend(data)
+
+    def flush(self):
+        pass
+
+    def close(self):
+        self.closed = True
+
+
+class DummyProcess:
+    def __init__(self):
+        self.stdin = DummyProcessStdin()
+        self.stdout = io.BytesIO()
+
+    def poll(self):
+        return None
+
+
+def test_strip_ansi():
+    # Basic red color text
+    colored_text = "\x1b[31mFatal Error\x1b[0m: File not found"
+    assert strip_ansi(colored_text) == "Fatal Error: File not found"
+
+    # Complex formatting (Bold + Green)
+    complex_text = "\x1b[1m\x1b[32mSuccess\x1b[0m"
+    assert strip_ansi(complex_text) == "Success"
+
+    # Loading spinner edge case
+    spinner_text = "\x1b[?25l\x1b[2K\x1b[1G⠋ Loading..."
+    assert "Loading..." in strip_ansi(spinner_text)
+
+
+def test_read_stdin_forwards_input():
+    wrapper = CLIWrapper(["dummy"])
+    wrapper.running = True
+    wrapper.process = DummyProcess()
+
+    original_stdin = sys.stdin
+    try:
+        sys.stdin = DummyStdinStream(b"hello world\n")
+        wrapper._read_stdin()
+    finally:
+        sys.stdin = original_stdin
+
+    assert wrapper.process.stdin.written == b"hello world\n"
+    assert wrapper.process.stdin.closed is True

panopticon_cli-1.1.0/panopticon/cli.py

@@ -1,197 +0,0 @@
-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()

panopticon_cli-1.1.0/tests/test_cli.py

@@ -1,15 +0,0 @@
-from panopticon.cli import strip_ansi
-
-
-def test_strip_ansi():
-    # Basic red color text
-    colored_text = "\x1b[31mFatal Error\x1b[0m: File not found"
-    assert strip_ansi(colored_text) == "Fatal Error: File not found"
-
-    # Complex formatting (Bold + Green)
-    complex_text = "\x1b[1m\x1b[32mSuccess\x1b[0m"
-    assert strip_ansi(complex_text) == "Success"
-
-    # Loading spinner edge case
-    spinner_text = "\x1b[?25l\x1b[2K\x1b[1G⠋ Loading..."
-    assert "Loading..." in strip_ansi(spinner_text)