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

{panopticon_cli-1.0.0 → panopticon_cli-1.1.1}/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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: panopticon-cli
-Version: 1.0.0
+Version: 1.1.1
 Summary: The Cognitive Immune System for Autonomous CLI Agents.
 Author: Ak
 License: MIT
@@ -33,10 +33,9 @@ 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)
+[![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/)
-[![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.1}/README.md

@@ -1,44 +1,43 @@
-# 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)
+[![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** 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.1}/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.1.1/panopticon/cli.py

@@ -0,0 +1,278 @@
+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 = []
+
+    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, daemon=True)
+        t_out.start()
+        self.threads.append(t_out)
+
+        t_in = threading.Thread(target=self._forward_stdin, daemon=True)
+        t_in.start()
+        self.threads.append(t_in)
+
+        t_eval = threading.Thread(target=self._eval_loop, daemon=True)
+        t_eval.start()
+        self.threads.append(t_eval)
+
+        # Register cleanup on exit
+        atexit.register(self._cleanup)
+
+        try:
+            self.process.wait()
+        finally:
+            self.running = False
+            self._cleanup()
+
+    def _cleanup(self):
+        """Cleanly shutdown all threads and resources."""
+        self.running = False
+
+        # Close subprocess pipes
+        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 _forward_stdin(self):
+        """Forward stdin to subprocess, with non-blocking checks."""
+        try:
+            while self.running and self.process and self.process.poll() is None:
+                try:
+                    # Windows-safe non-blocking stdin read
+                    if sys.platform == "win32":
+                        # On Windows, use a small sleep to avoid 100% CPU
+                        time.sleep(0.05)
+                        # Try non-blocking read using a different approach
+                        if sys.stdin and not sys.stdin.closed:
+                            try:
+                                # This will still block, but with timeout via select on Unix
+                                line = sys.stdin.buffer.readline()
+                                if line:
+                                    if self.process.stdin and not self.process.stdin.closed:
+                                        self.process.stdin.write(line)
+                                        self.process.stdin.flush()
+                                else:
+                                    break  # EOF
+                            except (EOFError, OSError, ValueError):
+                                break
+                    else:
+                        # Unix/Linux: use select for non-blocking check
+                        import select
+
+                        ready, _, _ = select.select([sys.stdin], [], [], 0.1)
+                        if ready:
+                            line = sys.stdin.buffer.readline()
+                            if line:
+                                if self.process.stdin and not self.process.stdin.closed:
+                                    self.process.stdin.write(line)
+                                    self.process.stdin.flush()
+                            else:
+                                break  # EOF
+                except (EOFError, 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 _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 _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 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
+                    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: {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.0.0 → panopticon_cli-1.1.1}/panopticon/memory.py

@@ -1,56 +1,60 @@
-import sqlite3
-import os
-import re
-from typing import List, Dict
-
-class PersistentMemory:
-    """Production-grade procedural memory using keyword similarity routing."""
-    def __init__(self, db_path="panopticon_memory.db"):
-        self.db_path = db_path
-        self._init_db()
-
-    def _init_db(self):
-        # Flaw 3 Fix: Enable WAL and connection timeout for multi-process concurrency
-        with sqlite3.connect(self.db_path, timeout=10.0) as conn:
-            conn.execute("PRAGMA journal_mode=WAL;")
-            conn.execute("""
-                CREATE TABLE IF NOT EXISTS failures (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-                    reason TEXT,
-                    correction TEXT
-                )
-            """)
-
-    def record_failure(self, reason: str, correction: str):
-        with sqlite3.connect(self.db_path, timeout=10.0) as conn:
-            conn.execute(
-                "INSERT INTO failures (reason, correction) VALUES (?, ?)", 
-                (reason, correction)
-            )
-
-    def _extract_keywords(self, text: str) -> set:
-        words = re.findall(r'\b[a-zA-Z]{4,}\b', text.lower())
-        return set(words)
-
-    def get_relevant_failures(self, current_context: str, limit=3) -> List[Dict]:
-        """Retrieves past failures that have the highest word overlap with the current context."""
-        current_keywords = self._extract_keywords(current_context)
-        if not current_keywords:
-            return []
-
-        with sqlite3.connect(self.db_path, timeout=10.0) as conn:
-            cursor = conn.execute("SELECT reason, correction FROM failures")
-            all_failures = cursor.fetchall()
-
-        scored_failures = []
-        for reason, correction in all_failures:
-            reason_keywords = self._extract_keywords(reason)
-            # Calculate Jaccard-like overlap score
-            overlap = len(current_keywords.intersection(reason_keywords))
-            if overlap > 0:
-                scored_failures.append((overlap, {"reason": reason, "correction": correction}))
-
-        # Sort by highest overlap, then take top N
-        scored_failures.sort(key=lambda x: x[0], reverse=True)
-        return [f[1] for f in scored_failures[:limit]]
+import sqlite3
+import os
+import re
+from typing import List, Dict
+
+
+class PersistentMemory:
+    """Production-grade procedural memory using keyword similarity routing."""
+
+    def __init__(self, db_path="panopticon_memory.db"):
+        self.db_path = db_path
+        self._init_db()
+
+    def _init_db(self):
+        # Flaw 3 Fix: Enable WAL and connection timeout for multi-process concurrency
+        with sqlite3.connect(self.db_path, timeout=10.0) as conn:
+            conn.execute("PRAGMA journal_mode=WAL;")
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS failures (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    reason TEXT,
+                    correction TEXT
+                )
+            """)
+
+    def record_failure(self, reason: str, correction: str):
+        with sqlite3.connect(self.db_path, timeout=10.0) as conn:
+            conn.execute(
+                "INSERT INTO failures (reason, correction) VALUES (?, ?)",
+                (reason, correction),
+            )
+
+    def _extract_keywords(self, text: str) -> set:
+        words = re.findall(r"\b[a-zA-Z]{4,}\b", text.lower())
+        return set(words)
+
+    def get_relevant_failures(self, current_context: str, limit=3) -> List[Dict]:
+        """Retrieves past failures that have the highest word overlap with the current context."""
+        current_keywords = self._extract_keywords(current_context)
+        if not current_keywords:
+            return []
+
+        with sqlite3.connect(self.db_path, timeout=10.0) as conn:
+            cursor = conn.execute("SELECT reason, correction FROM failures")
+            all_failures = cursor.fetchall()
+
+        scored_failures = []
+        for reason, correction in all_failures:
+            reason_keywords = self._extract_keywords(reason)
+            # Calculate Jaccard-like overlap score
+            overlap = len(current_keywords.intersection(reason_keywords))
+            if overlap > 0:
+                scored_failures.append(
+                    (overlap, {"reason": reason, "correction": correction})
+                )
+
+        # Sort by highest overlap, then take top N
+        scored_failures.sort(key=lambda x: x[0], reverse=True)
+        return [f[1] for f in scored_failures[:limit]]