panopticon-cli 1.0.0__py3-none-any.whl

panopticon/__init__.py

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

panopticon/cli.py

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

panopticon/memory.py

@@ -0,0 +1,56 @@
+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]]

panopticon/observer.py

@@ -0,0 +1,64 @@
+import json
+import os
+from typing import List, Dict, Callable
+from .policies import BasePolicy
+
+class InterventionException(Exception):
+    def __init__(self, message: str, course_correction: str):
+        super().__init__(message)
+        self.course_correction = course_correction
+
+class PanopticonObserver:
+    def __init__(self, policies: List[BasePolicy] = None, telemetry_file: str = "panopticon_telemetry.jsonl"):
+        self.policies = policies or []
+        self.telemetry_stream = []
+        self.telemetry_file = telemetry_file
+        
+        if os.path.exists(self.telemetry_file):
+            os.remove(self.telemetry_file)
+
+    def _broadcast(self, event_type: str, data: Dict):
+        """Writes to a JSONL file so the Pantheon OS Dashboard can tail it in real-time."""
+        payload = {"event": event_type, **data}
+        with open(self.telemetry_file, "a") as f:
+            f.write(json.dumps(payload) + "\n")
+
+    def log_action(self, agent_name: str, thought: str, action: str, tokens_used: int):
+        entry = {
+            "agent": agent_name,
+            "thought": thought,
+            "action": action,
+            "tokens": tokens_used
+        }
+        # Flaw 2 Fix: Bounded memory to prevent leaks
+        self.telemetry_stream.append(entry)
+        if len(self.telemetry_stream) > 20:
+            self.telemetry_stream.pop(0)
+        self._broadcast("step", entry)
+        self._evaluate_state(agent_name)
+
+    def _evaluate_state(self, agent_name: str):
+        for policy in self.policies:
+            is_violating, reason, correction = policy.evaluate(self.telemetry_stream)
+            if is_violating:
+                self._broadcast("guillotine", {
+                    "agent": agent_name,
+                    "reason": reason,
+                    "correction": correction
+                })
+                self._trigger_guillotine(agent_name, reason, correction)
+
+    def _trigger_guillotine(self, agent_name: str, reason: str, correction: str):
+        raise InterventionException(message=reason, course_correction=correction)
+
+    def watch(self, agent_name: str):
+        def decorator(func: Callable):
+            def wrapper(*args, **kwargs):
+                self._broadcast("start", {"agent": agent_name})
+                try:
+                    return func(*args, **kwargs)
+                except InterventionException as e:
+                    self._broadcast("interrupt", {"agent": agent_name, "correction": e.course_correction})
+                    return {"status": "interrupted", "correction": e.course_correction}
+            return wrapper
+        return decorator

panopticon/policies.py

@@ -0,0 +1,53 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Tuple
+from .sentinel import Sentinel
+
+class BasePolicy(ABC):
+    @abstractmethod
+    def evaluate(self, telemetry_stream: List[Dict]) -> Tuple[bool, str, str]:
+        pass
+
+
+import difflib
+
+class AntiLoopPolicy(BasePolicy):
+    def __init__(self, window: int = 3, threshold: float = 0.85):
+        self.window = window
+        self.threshold = threshold
+
+    def evaluate(self, telemetry_stream: List[Dict]) -> Tuple[bool, str, str]:
+        if len(telemetry_stream) < self.window:
+            return False, "", ""
+        
+        recent = [entry.get("thought", "").strip() for entry in telemetry_stream[-self.window:]]
+        if not recent[0]:
+            return False, "", ""
+            
+        # Flaw 3 Fix: Fuzzy match chunks (≥85% similar) to ignore timestamps/spinners
+        ratios = [difflib.SequenceMatcher(None, recent[0], t).ratio() for t in recent]
+        
+        if all(r >= self.threshold for r in ratios):
+            return True, "Heuristic: Fuzzy repetition loop detected", "[SYSTEM OVERRIDE] You are repeating the exact same actions. Try a different strategy."
+        return False, "", ""
+
+class BlacklistPolicy(BasePolicy):
+    def __init__(self, forbidden_patterns: List[str]):
+        self.forbidden_patterns = forbidden_patterns
+
+    def evaluate(self, telemetry_stream: List[Dict]) -> Tuple[bool, str, str]:
+        if not telemetry_stream:
+            return False, "", ""
+        latest = telemetry_stream[-1].get("thought", "").lower()
+        for pattern in self.forbidden_patterns:
+            if pattern.lower() in latest:
+                return True, f"Blacklisted pattern detected: '{pattern}'", f"[SYSTEM OVERRIDE] You triggered a forbidden action ({pattern}). Reverse course immediately."
+        return False, "", ""
+
+class AdversarialLogicCheck(BasePolicy):
+    def __init__(self, target_agent: str = "claude"):
+        self.sentinel = Sentinel(target_agent=target_agent)
+
+    def evaluate(self, telemetry_stream: List[Dict]) -> Tuple[bool, str, str]:
+        if len(telemetry_stream) >= 2:
+            return self.sentinel.evaluate_trajectory(telemetry_stream)
+        return False, "", ""

panopticon/sentinel.py

@@ -0,0 +1,122 @@
+import json
+import os
+from typing import List, Dict, Tuple
+from .memory import PersistentMemory
+
+class Sentinel:
+    """
+    The Universal Meta-Agent. 
+    Dynamically routes its semantic evaluation to match the API of the agent it is observing.
+    """
+    def __init__(self, target_agent: str = "claude"):
+        self.target_agent = target_agent.lower()
+        self.memory = PersistentMemory()
+        
+    def evaluate_trajectory(self, telemetry_stream: List[Dict]) -> Tuple[bool, str, str]:
+        if len(telemetry_stream) < 2:
+            return False, "", ""
+            
+        recent_chunks = [e.get("thought", "")[:500] for e in telemetry_stream[-3:]]
+        context_str = " ".join(recent_chunks)
+        
+        # Pull dynamically relevant failures based on current context
+        past_failures = self.memory.get_relevant_failures(current_context=context_str, limit=3)
+        
+        prompt = f"""
+Execution trace:
+{json.dumps(recent_chunks)}
+
+Relevant past failures (Do not repeat these mistakes):
+{json.dumps(past_failures)}
+
+Is the agent stuck in a loop, failing logical progress, or repeating a past recorded failure?
+Respond ONLY in JSON:
+{{"is_failing": true/false, "reason": "why if true", "correction_prompt": "directive prompt to inject to break the loop or correct the logic. empty if not failing"}}
+"""
+        try:
+            result_text = self._route_to_llm(prompt)
+            
+            # Flaw 4 Fix: Robust regex JSON extraction ignoring conversational fluff
+            import re
+            match = re.search(r'\{.*\}', result_text, re.DOTALL)
+            if match:
+                result_text = match.group(0)
+            else:
+                return False, "", ""
+                
+            data = json.loads(result_text)
+            
+            if data.get("is_failing"):
+                reason = data.get("reason", "Failure detected")
+                correction = data.get("correction_prompt", "Discard approach.")
+                self.memory.record_failure(reason, correction)
+                return True, reason, correction
+            return False, "", ""
+            
+        except Exception as e:
+            # Flaw 4 Fix: Don't fail silently on critical API configuration errors
+            error_str = str(e).lower()
+            if "api_key" in error_str or "auth" in error_str or "not found" in error_str:
+                raise RuntimeError(f"\n[PANOPTICON FATAL ERROR] Missing or invalid API key for {self.target_agent}: {e}")
+            
+            # For random network timeouts, ignore and try again next loop
+            return False, "", ""
+
+    def _route_to_llm(self, prompt: str) -> str:
+        """Dynamically switch the meta-agent API based on the target CLI command, with intelligent fallbacks."""
+        agent = self.target_agent
+        
+        # 1. Explicit matching based on command name
+        if "agy" in agent or "gemini" in agent:
+            if os.environ.get("GEMINI_API_KEY"): return self._call_gemini(prompt)
+        elif "gpt" in agent or "codex" in agent or "openai" in agent:
+            if os.environ.get("OPENAI_API_KEY"): return self._call_openai(prompt)
+        elif "claude" in agent:
+            if os.environ.get("ANTHROPIC_API_KEY"): return self._call_anthropic(prompt)
+            
+        # 2. Flaw 3 Fix: Intelligent Fallback if explicit match fails or agent is generic (e.g. 'python')
+        if os.environ.get("ANTHROPIC_API_KEY"):
+            return self._call_anthropic(prompt)
+        elif os.environ.get("GEMINI_API_KEY"):
+            return self._call_gemini(prompt)
+        elif os.environ.get("OPENAI_API_KEY"):
+            return self._call_openai(prompt)
+        else:
+            raise RuntimeError("\n[PANOPTICON FATAL] No API keys found! Please set ANTHROPIC_API_KEY, GEMINI_API_KEY, or OPENAI_API_KEY.")
+
+    def _call_anthropic(self, prompt: str) -> str:
+        from anthropic import Anthropic
+        client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
+        resp = client.messages.create(
+            model="claude-3-5-haiku-20241022",
+            max_tokens=150,
+            temperature=0.0,
+            system="Strict meta-agent. Output JSON.",
+            messages=[{"role": "user", "content": prompt}]
+        )
+        return resp.content[0].text
+
+    def _call_openai(self, prompt: str) -> str:
+        from openai import OpenAI
+        client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+        resp = client.chat.completions.create(
+            model="gpt-4o-mini",
+            response_format={ "type": "json_object" },
+            messages=[
+                {"role": "system", "content": "Strict meta-agent. Output JSON."},
+                {"role": "user", "content": prompt}
+            ]
+        )
+        return resp.choices[0].message.content
+
+    def _call_gemini(self, prompt: str) -> str:
+        import google.generativeai as genai
+        genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        resp = model.generate_content(
+            "Strict meta-agent. Output JSON.\n\n" + prompt,
+            generation_config=genai.types.GenerationConfig(
+                response_mime_type="application/json",
+            )
+        )
+        return resp.text

panopticon_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: panopticon-cli
+Version: 1.0.0
+Summary: The Cognitive Immune System for Autonomous CLI Agents.
+Author: Ak
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: anthropic>=0.30.0
+Requires-Dist: google-generativeai>=0.5.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Dynamic: license-file
+
+# 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_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+panopticon/__init__.py,sha256=v3e7coADLLuL6QbrMBCmLsYrXpwIZJ-3A_k4KhZ_NKM,293
+panopticon/cli.py,sha256=NMUiyE6qEo_IgdwjzUMyI5tg_X-io0D8SIt4vJ3nkzw,5773
+panopticon/memory.py,sha256=tsET5eL_V9sqN3PyNWT7kDiDB4sew-o8SXnipclFr-w,2292
+panopticon/observer.py,sha256=cwhDuh_CpYaKHzPKhs16MFPvco1_QBooL5XZW3W4ohU,2625
+panopticon/policies.py,sha256=-209r0LsG-6DAZRs4n2ZaX3ft0sFORuApLxYmkBkXd8,2204
+panopticon/sentinel.py,sha256=qpb0Wuj3-oyafM_nDGMoR-4xQ2Hmdn4kh1csffP_Zow,5275
+panopticon_cli-1.0.0.dist-info/licenses/LICENSE,sha256=RVE6q1ztFgMreAcgS3agYLyTymk3LfWEoCkYr4uQv64,1059
+panopticon_cli-1.0.0.dist-info/METADATA,sha256=-Rvc6kvvzbUUsSHJtbeVilPyB3_tNz8yKQ1LhH75_J8,4096
+panopticon_cli-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+panopticon_cli-1.0.0.dist-info/entry_points.txt,sha256=gQ8sXaenMhuOvpNF7j1SZn4LyT8FovkoZtLNPYuF1MA,51
+panopticon_cli-1.0.0.dist-info/top_level.txt,sha256=cwfjzY-pXdd-8YL4DE2KkDodExs8OXI_gUnFTJ8i1cQ,11
+panopticon_cli-1.0.0.dist-info/RECORD,,

panopticon_cli-1.0.0.dist-info/WHEEL

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

panopticon_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+panopticon = panopticon.cli:main

panopticon_cli-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +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.

panopticon_cli-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+panopticon