aizen-ai-cli 2.2.2__py3-none-any.whl

aizen/utils.py

@@ -0,0 +1,339 @@
+import fnmatch
+import os
+import re
+import shutil
+import time
+import urllib.request
+from datetime import datetime
+
+from rich.table import Table
+
+from .config import BACKUPS_DIR
+from .logging_config import logger
+
+# ─── Optional tiktoken for accurate token counting ─────────────────────────────
+
+_tiktoken_encoding = None
+
+def _get_tiktoken_encoding():
+    """Lazily load tiktoken for accurate token counting. Falls back to estimation."""
+    global _tiktoken_encoding
+    if _tiktoken_encoding is not None:
+        return _tiktoken_encoding
+
+    try:
+        import tiktoken  # pyrefly: ignore[missing-import]
+        # cl100k_base covers GPT-4, Claude, and most modern models
+        _tiktoken_encoding = tiktoken.get_encoding("cl100k_base")
+    except ImportError:
+        _tiktoken_encoding = False  # Mark as unavailable
+    return _tiktoken_encoding
+
+
+class Struct:
+    """Simple namespace for converting dicts to attribute-access objects."""
+    def __init__(self, **entries):
+        self.__dict__.update(entries)
+
+
+class TokenTracker:
+    """Track token usage and session statistics with accurate or estimated counting."""
+
+    def __init__(self):
+        self.total_input_tokens: int = 0
+        self.total_output_tokens: int = 0
+        self.api_reported_input: int = 0
+        self.api_reported_output: int = 0
+        self.message_count: int = 0
+        self.start_time: datetime = datetime.now()
+        self._using_api_usage: bool = False
+
+    def add_usage(self, input_tokens: int, output_tokens: int):
+        """Add estimated token usage for a single exchange."""
+        self.total_input_tokens += input_tokens
+        self.total_output_tokens += output_tokens
+        self.message_count += 1
+
+    def add_api_usage(self, prompt_tokens: int, completion_tokens: int):
+        """
+        Add API-reported token usage (more accurate than estimation).
+        When API usage is available, it takes precedence in the summary.
+        """
+        self.api_reported_input += prompt_tokens
+        self.api_reported_output += completion_tokens
+        self._using_api_usage = True
+        self.message_count += 1
+
+    def estimate_tokens(self, text: str) -> int:
+        """
+        Estimate token count for a given text.
+        Uses tiktoken if available, falls back to word-based heuristic.
+        """
+        if not text:
+            return 0
+
+        enc = _get_tiktoken_encoding()
+        if enc and enc is not False:
+            try:
+                return len(enc.encode(text))
+            except Exception as e:
+                logger.debug("tiktoken encoding failed: %s", e)
+
+        # Fallback: ~1.3 tokens per word (rough but usable)
+        return max(1, int(len(text.split()) * 1.3))
+
+    @property
+    def total_tokens(self) -> int:
+        if self._using_api_usage:
+            return self.api_reported_input + self.api_reported_output
+        return self.total_input_tokens + self.total_output_tokens
+
+    @property
+    def input_tokens(self) -> int:
+        if self._using_api_usage:
+            return self.api_reported_input
+        return self.total_input_tokens
+
+    @property
+    def output_tokens(self) -> int:
+        if self._using_api_usage:
+            return self.api_reported_output
+        return self.total_output_tokens
+
+    def get_estimated_cost(self, active_model: str) -> float:
+        """Returns the estimated cost in USD for the current session."""
+        return get_model_cost(active_model, self.input_tokens, self.output_tokens)
+
+    @property
+    def session_duration(self) -> str:
+        delta = datetime.now() - self.start_time
+        minutes = int(delta.total_seconds() // 60)
+        seconds = int(delta.total_seconds() % 60)
+        if minutes > 0:
+            return f"{minutes}m {seconds}s"
+        return f"{seconds}s"
+
+    def get_summary_table(self, active_model: str = "") -> Table:
+        source = "API-reported" if self._using_api_usage else "Estimated"
+        enc = _get_tiktoken_encoding()
+        method = "tiktoken" if (enc and enc is not False and not self._using_api_usage) else "heuristic"
+
+        table = Table(title="📊 Session Usage", border_style="magenta", show_header=True)
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", style="white")
+        table.add_row("Messages", str(self.message_count))
+        table.add_row("Input Tokens", f"{self.input_tokens:,}")
+        table.add_row("Output Tokens", f"{self.output_tokens:,}")
+        table.add_row("Total Tokens", f"{self.total_tokens:,}")
+
+        if active_model:
+            cost = get_model_cost(active_model, self.input_tokens, self.output_tokens)
+            if cost > 0:
+                table.add_row("Est. Cost", f"${cost:.4f} USD")
+            else:
+                table.add_row("Est. Cost", "Unknown (Pricing not in DB)")
+
+        table.add_row("Counting Method", f"{source} ({method})")
+        table.add_row("Session Duration", self.session_duration)
+        return table
+
+# Pricing per 1,000,000 tokens (input, output) in USD
+MODEL_PRICING = {
+    # Anthropic
+    "anthropic/claude-sonnet-4": (3.00, 15.00),
+    "anthropic/claude-3.5-sonnet": (3.00, 15.00),
+    "anthropic/claude-3.7-sonnet": (3.00, 15.00),
+    "anthropic/claude-3-opus": (15.00, 75.00),
+    "anthropic/claude-3.5-haiku": (0.80, 4.00),
+    "anthropic/claude-4-opus": (15.00, 75.00),
+    # Google
+    "google/gemini-2.5-pro": (1.25, 10.00),
+    "google/gemini-2.5-flash": (0.15, 0.60),
+    "google/gemini-2.0-flash": (0.10, 0.40),
+    # OpenAI
+    "openai/gpt-4o": (2.50, 10.00),
+    "openai/gpt-4o-mini": (0.15, 0.60),
+    "openai/gpt-4.1": (2.00, 8.00),
+    "openai/gpt-4.1-mini": (0.40, 1.60),
+    "openai/gpt-4.1-nano": (0.10, 0.40),
+    "openai/o1": (15.00, 60.00),
+    "openai/o3": (10.00, 40.00),
+    "openai/o3-mini": (1.10, 4.40),
+    "openai/o4-mini": (1.10, 4.40),
+    # DeepSeek
+    "deepseek/deepseek-chat-v3": (0.27, 1.10),
+    "deepseek/deepseek-chat": (0.14, 0.28),
+    "deepseek/deepseek-r1": (0.55, 2.19),
+    # Meta
+    "meta-llama/llama-4-maverick": (0.20, 0.60),
+    "meta-llama/llama-3.3-70b-instruct": (0.10, 0.25),
+}
+
+def get_model_cost(model_name: str, input_tokens: int, output_tokens: int) -> float:
+    """Calculate the estimated cost for a given model and token count."""
+    for known_model, (in_price, out_price) in MODEL_PRICING.items():
+        if known_model in model_name.lower():
+            return (input_tokens * in_price / 1_000_000) + (output_tokens * out_price / 1_000_000)
+    return 0.0
+
+
+class BackupManager:
+    """Manage file backups for undo operations."""
+
+    def __init__(self):
+        os.makedirs(BACKUPS_DIR, exist_ok=True)
+        self.undo_stack: list[tuple[str, str, str]] = []  # (original_path, backup_path, timestamp)
+
+    def backup(self, filepath: str) -> str | None:
+        """Create a backup before modification. Returns backup path."""
+        if not os.path.exists(filepath):
+            return None
+        try:
+            abs_path = os.path.abspath(filepath)
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+            basename = os.path.basename(filepath)
+            backup_name = f"{timestamp}_{basename}"
+            backup_path = os.path.join(BACKUPS_DIR, backup_name)
+            shutil.copy2(abs_path, backup_path)
+            self.undo_stack.append((abs_path, backup_path, timestamp))
+            return backup_path
+        except Exception as e:
+            logger.debug("Failed to backup file %s: %s", filepath, e)
+            return None
+
+    def undo(self) -> str:
+        """Undo the last file modification."""
+        if not self.undo_stack:
+            return "Nothing to undo."
+
+        original_path, backup_path, _ = self.undo_stack.pop()
+
+        if not os.path.exists(backup_path):
+            return f"Backup file not found: {backup_path}"
+
+        try:
+            shutil.copy2(backup_path, original_path)
+            os.remove(backup_path)
+            return f"✓ Restored {os.path.basename(original_path)} to its previous state."
+        except Exception as e:
+            return f"Error restoring file: {e}"
+
+    def cleanup(self, max_age_hours: int = 24):
+        """Remove backups older than max_age_hours."""
+        try:
+            now = time.time()
+            for f in os.listdir(BACKUPS_DIR):
+                path = os.path.join(BACKUPS_DIR, f)
+                if os.path.isfile(path):
+                    age_hours = (now - os.path.getmtime(path)) / 3600
+                    if age_hours > max_age_hours:
+                        os.remove(path)
+        except Exception as e:
+            logger.debug("Cleanup backups failed: %s", e)
+
+
+def truncate_output(text: str, max_chars: int = 4000) -> str:
+    if len(text) <= max_chars:
+        return text
+    half = max_chars // 2
+    return (
+        f"{text[:half]}\n\n"
+        f"[... TRUNCATED {len(text) - max_chars} chars ...]\n\n"
+        f"{text[-half:]}"
+    )
+
+
+def load_gitignore_patterns() -> list:
+    patterns = [
+        ".git/", "node_modules/", "__pycache__/", "venv/", ".env",
+        "dist/", "build/", "*.egg-info/", ".DS_Store",
+    ]
+    if os.path.exists(".gitignore"):
+        try:
+            with open(".gitignore", encoding="utf-8", errors="ignore") as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#"):
+                        patterns.append(line)
+        except Exception as e:
+            logger.debug("Failed to load .gitignore: %s", e)
+    return patterns
+
+
+def should_ignore(path: str, patterns: list) -> bool:
+    path = os.path.normpath(path)
+    parts = path.split(os.sep)
+    for pattern in patterns:
+        clean_pattern = pattern.rstrip("/")
+        for part in parts:
+            if fnmatch.fnmatch(part, clean_pattern):
+                return True
+        if fnmatch.fnmatch(path, clean_pattern):
+            return True
+    return False
+
+
+def fetch_url_content(url: str, timeout: int = 10) -> str:
+    """Fetch content from a URL and strip HTML tags if it's a webpage."""
+    try:
+        req = urllib.request.Request(
+            url,
+            headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AizenAgent'}
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            content_type = response.headers.get_content_type()
+            charset = response.headers.get_content_charset() or 'utf-8'
+            raw_data = response.read().decode(charset, errors='replace')
+
+            if 'html' in content_type:
+                # Basic HTML stripping
+                # Remove script and style elements
+                text = re.sub(r'<(script|style)[^>]*>.*?</\1>', '', raw_data, flags=re.IGNORECASE | re.DOTALL)
+                # Remove HTML tags
+                text = re.sub(r'<[^>]+>', ' ', text)
+                # Unescape common HTML entities
+                text = text.replace('&nbsp;', ' ').replace('&lt;', '<').replace('&gt;', '>').replace('&amp;', '&').replace('&quot;', '"')
+                # Collapse whitespace
+                text = re.sub(r'\s+', ' ', text).strip()
+                return text
+
+            return raw_data
+    except Exception as e:
+        return f"Error fetching URL: {e}"
+
+
+def generate_directory_tree(path: str) -> str:
+    """Generate a formatted text tree of a directory, respecting .gitignore."""
+    ignore_patterns = load_gitignore_patterns()
+
+    lines = []
+
+    def _walk(current_path: str, prefix: str = ""):
+        try:
+            entries = sorted(os.listdir(current_path))
+        except PermissionError:
+            lines.append(f"{prefix}[Permission Denied]")
+            return
+
+        # Filter entries
+        valid_entries = []
+        for entry in entries:
+            full_path = os.path.join(current_path, entry)
+            if not should_ignore(full_path, ignore_patterns):
+                valid_entries.append((entry, full_path))
+
+        for i, (entry, full_path) in enumerate(valid_entries):
+            is_last = i == (len(valid_entries) - 1)
+            connector = "└── " if is_last else "├── "
+
+            if os.path.isdir(full_path):
+                lines.append(f"{prefix}{connector}{entry}/")
+                new_prefix = prefix + ("    " if is_last else "│   ")
+                _walk(full_path, new_prefix)
+            else:
+                lines.append(f"{prefix}{connector}{entry}")
+
+    base_name = os.path.basename(os.path.abspath(path)) or path
+    lines.append(f"{base_name}/")
+    _walk(path)
+    return "\n".join(lines)

aizen_ai_cli-2.2.2.dist-info/METADATA

@@ -0,0 +1,267 @@
+Metadata-Version: 2.4
+Name: aizen-ai-cli
+Version: 2.2.2
+Summary: Aizen AI Agent — A professional-grade AI coding assistant for your terminal.
+Author: Irtaza Malik
+License: MIT
+Project-URL: Homepage, https://github.com/irtaza302/aizen-agent
+Project-URL: Repository, https://github.com/irtaza302/aizen-agent
+Project-URL: Issues, https://github.com/irtaza302/aizen-agent/issues
+Keywords: ai,cli,coding-assistant,terminal,openrouter,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: rich>=13.0
+Requires-Dist: prompt_toolkit>=3.0
+Requires-Dist: mcp>=1.0.0
+Provides-Extra: tiktoken
+Requires-Dist: tiktoken>=0.5; extra == "tiktoken"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+
+# Aizen AI Agent 🚀
+
+[![CI](https://github.com/irtaza302/aizen-agent/actions/workflows/ci.yml/badge.svg)](https://github.com/irtaza302/aizen-agent/actions/workflows/ci.yml)
+
+A professional-grade AI coding assistant that runs directly in your terminal. Aizen reads your code, writes files with surgical precision, runs commands safely, and helps you build faster — all from a beautifully designed CLI.
+
+## ✨ Features
+
+### Core
+- **Asynchronous Architecture** — Fully asynchronous operations leveraging `asyncio` and `AsyncOpenAI` for concurrent processing, parallel tool runs, and streaming.
+- **Rich Markdown Rendering** — AI responses are rendered with full Markdown formatting (headers, code blocks, lists, bold/italic) via Rich's live display.
+- **Streaming with Live Preview** — Watch responses render in real-time inside a styled panel with an animated thinking spinner.
+- **Surgical File Editing** — The `edit_file` tool makes precise search-and-replace edits with color-coded diff previews, instead of rewriting entire files.
+- **SQLite Session Persistence** — Session storage is powered by a SQLite database (`~/.aizen_sessions/aizen.db`), auto-migrating older JSON sessions.
+- **Project-Specific Rules** — Customizes agent behavior per repository by auto-loading `.aizen_rules` or `.cursorrules` from the current working directory.
+- **Smart Autocomplete** — `@`-mention files with Tab completion that respects `.gitignore` and supports directory traversal.
+
+### Tools
+Aizen has 9 built-in tools the AI can use:
+
+| Tool | Description |
+|------|-------------|
+| `read_file` | Read file contents before making changes |
+| `write_file` | Create new files (with preview) |
+| `edit_file` | Surgical search-and-replace on existing files (with diff preview) |
+| `run_command` | Execute shell commands (supports background execution; safe commands auto-run, dangerous ones require approval) |
+| `check_background_task` | Check the status and read recent output of a command running in the background |
+| `kill_background_task` | Kill a running background task |
+| `list_directory` | List files/folders with sizes, respecting `.gitignore` |
+| `grep_search` | Search for text or regex patterns across the codebase |
+| `find_files` | Find files by glob pattern (e.g., `*.py`, `Dockerfile`) |
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show all available commands |
+| `/model [name]` | View or switch the active AI model (saves as default) |
+| `/clear` | Clear conversation history |
+| `/drop` | Drop attached files/URLs/commands from history to save tokens |
+| `/save [name]` | Save current conversation to SQLite database |
+| `/load [name]` | Load a previously saved conversation |
+| `/checkpoint [name]` | Save a conversation snapshot to memory |
+| `/restore [name]` | Restore a saved conversation checkpoint |
+| `/usage` | Show token usage, estimated session cost (USD), and statistics |
+| `/commit` | Auto-generate a commit message for staged/unstaged changes and commit them |
+| `/diff` | Show all uncommitted changes (staged, unstaged, untracked) |
+| `/compact` | Summarize older messages using AI (fallback to text-summarization) to save tokens |
+| `/undo` | Undo the last file modification |
+| `/retry` | Retry the last message |
+| `/copy` | Copy last AI response to clipboard |
+| `/export [file]` | Export conversation to a Markdown file |
+| `/config` | View current configuration |
+| `/mcp` | View configured MCP servers and their connection status |
+
+### Safety & UX
+- **Command Safety** — Read-only commands (`ls`, `cat`, `git status`, etc.) auto-execute. Destructive commands (`rm`, `sudo`, etc.) always require confirmation.
+- **`--yolo` Mode** — Auto-approve all operations for power users.
+- **Background Tasks** — Run builds, tests, or other long-running tasks asynchronously while continuing to interact with Aizen.
+- **File Backups** — Every file modification creates a backup. Use `/undo` to restore.
+- **Multi-line Input** — End a line with `\` to continue on the next line.
+- **Session Persistence** — Conversations auto-save on exit to SQLite. Use `/save` and `/load` to manage.
+- **Cost Tracking & Token Usage** — Live tracking of input/output tokens, session duration, and estimated session cost in USD.
+- **Structured Logging** — Rotated file logging at `~/.aizen_logs/aizen.log` plus verbose console debugging logs via `--verbose`.
+- **Graceful Error Recovery** — Helpful hints for common API errors (invalid key, rate limits, timeouts).
+
+## Dependencies
+
+- `openai` — OpenAI-compatible API client
+- `python-dotenv` — Environment variable management
+- `rich` — Rich text, Markdown rendering, panels, tables, and live display
+- `prompt_toolkit` — Interactive command line with autocomplete
+
+## Installation
+
+### 1. Python (pip / pipx) — Recommended
+```bash
+pipx install aizen-ai-cli
+# Or:
+pip install aizen-ai-cli
+```
+
+### 2. NPM (Node.js)
+```bash
+npm install -g aizen-ai-cli
+```
+
+### 3. Homebrew (macOS)
+```bash
+brew tap irtaza302/aizen
+brew install aizen
+```
+
+### 4. Local Development
+```bash
+git clone https://github.com/irtaza302/aizen-agent.git
+cd aizen-agent
+pip install -r requirements.txt
+python aizen.py
+```
+
+## Usage
+
+```bash
+aizen
+```
+
+On first launch, you'll be prompted for your [OpenRouter API key](https://openrouter.ai/keys). It's saved securely to `~/.aizen_config.json`.
+
+### Command Line Arguments
+
+| Flag | Description |
+|------|-------------|
+| `--version` | Show version |
+| `--model <name>` | Override the default model for this session |
+| `--reset-key` | Clear and re-enter your API key |
+| `--set-base-url <url>` | Set custom API base URL (e.g., `http://localhost:11434/v1` for Ollama) |
+| `--yolo` | Auto-approve all file writes and command executions |
+| `--verbose` | Enable verbose logging output to the console |
+
+### Attaching Context (`@`)
+
+Type `@` followed by a filename, directory, web URL, or command to give Aizen context. Autocomplete filters out `.gitignore`d files:
+
+- **Files:** `@aizen.py` attaches the file contents.
+- **Directories:** `@tests/` generates and attaches a visual directory tree respecting `.gitignore`.
+- **URLs:** `@https://docs.python.org/...` fetches the webpage, converts it to markdown, and attaches it.
+- **Commands:** `@cmd:"pytest"` or `@cmd:ls` securely runs the command in the background and injects its `stdout` and `stderr` directly into the prompt.
+
+```
+👤 You
+❯ Can you refactor @aizen.py to use async?
+
+👤 You
+❯ Explain this output: @cmd:"npm run build"
+```
+
+### Multi-line Input
+
+End a line with `\` to continue typing on the next line:
+
+```
+👤 You
+❯ Write a function that \
+⋮  takes a list of numbers \
+⋮  and returns the sorted unique values
+```
+
+## Configuration
+
+Aizen stores its config in `~/.aizen_config.json`:
+
+```json
+{
+  "OPENROUTER_API_KEY": "sk-or-...",
+  "API_BASE_URL": "https://openrouter.ai/api/v1",
+  "DEFAULT_MODEL": "anthropic/claude-sonnet-4"
+}
+```
+
+### Model Context Protocol (MCP) Support
+
+Aizen supports integrating with external [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) servers to extend its capabilities (e.g. connecting to local databases, searching the web, or accessing custom APIs).
+
+To configure MCP servers, add an `"mcp_servers"` block to your `~/.aizen_config.json`:
+
+```json
+{
+  "mcp_servers": {
+    "sqlite": {
+      "command": "uvx",
+      "args": ["mcp-server-sqlite", "--db-path", "~/test.db"]
+    },
+    "everything": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-everything"]
+    }
+  }
+}
+```
+
+When you start Aizen, it will automatically connect to these servers and make their tools available to the AI.
+
+Sessions are saved in a SQLite database at `~/.aizen_sessions/aizen.db`, and file backups are placed in `~/.aizen_backups/`.
+
+### 📂 Project-Specific Rules
+
+Aizen supports loading custom, project-specific rules files (such as `.aizen_rules` or `.cursorrules`) from the root of your project directory. 
+When Aizen starts, it checks for these files in the current working directory in the following order:
+1. `.aizen_rules`
+2. `.cursorrules`
+
+If one is found, Aizen automatically appends its contents to the system prompt. This allows you to enforce codebase-specific styling guidelines, coding standards, or project rules without editing Aizen's global configuration.
+
+### 🔄 Background Task Management
+
+For long-running processes (e.g., running test suites, starting local dev servers, or building bundles), you can run commands in the background asynchronously:
+- Aizen's `run_command` tool supports a boolean `background` parameter. If set to `true`, the tool immediately returns a unique `task_id` (e.g., `bg_a1b2c3d4`).
+- You can inspect the status and read the recent stdout/stderr output of a background task using the `check_background_task` tool.
+- You can terminate any active background task using the `kill_background_task` tool.
+
+This allows you to continue discussing other topics or refactoring files with Aizen while your tests or builds run in parallel.
+
+### 💰 Cost Tracking
+
+Aizen dynamically estimates session costs in USD for known models based on token usage:
+- Input and output tokens are tracked in real-time.
+- The estimated session cost is displayed in the CLI status bar and summary tables (via the `/usage` command).
+- The cost calculations support popular models from Anthropic (Claude 3.5/3.7 Sonnet, Opus, Haiku), Google (Gemini 2.5 Pro/Flash), and OpenAI (GPT-4o, o1, o3-mini).
+
+### 📌 Session Checkpoints & Restoring
+
+You can save and restore conversation snapshots at any point during your session:
+- `/checkpoint [name]`: Save the current conversation messages history as a named snapshot in memory.
+- `/restore [name]`: Revert the conversation history to the specified checkpoint. If run without a name, it lists all currently active checkpoints.
+
+This is extremely useful when experimenting with different implementation approaches or when recovering from an unintended direction.
+
+### 📝 Structured Logging
+
+All internal activities, tool calls, and API events are written to a rotating file logger:
+- Logs are located at `~/.aizen_logs/aizen.log`.
+- Up to three rotated log files are kept (5 MB per file limit).
+- You can run Aizen with the `--verbose` flag to mirror log output directly to the console stderr stream.
+
+## Publishing & Development
+
+Use the included `publish.sh` script to build and publish across all platforms (PyPI, NPM, and PyInstaller binaries).

aizen_ai_cli-2.2.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+aizen/__init__.py,sha256=V9ejtMhPwGtednFQutzq536YgPC4HtU66mtM0imGDdo,76
+aizen/commands.py,sha256=rMhrmTCNXy7OcH8QU8FzyLnhIiFLnuvMV0m8dp05xKQ,29957
+aizen/config.py,sha256=DA5wyyOjT9ML4w5-eWSlaZUtzcTHYB6yVTHkzFc3UW8,14103
+aizen/context.py,sha256=xnuKQ7bX9NhbjcdtOdnejiPU89UX68yCZqAnnulFH2U,5871
+aizen/exceptions.py,sha256=2RTYNDDSQ3l-JCuWT2opM4IEKQgoQCNtFpqKVbVxDEE,1065
+aizen/logging_config.py,sha256=FWmiEK070F2E9yFPcqah1pRa9_pslXAU4I0yQyjMOzM,2176
+aizen/main.py,sha256=-xuhfG0hNzo79142gCaWbIdUU1Sx4XlUhgzaamgfMr8,26026
+aizen/mcp.py,sha256=ssAI2F9HoarbtUK4oGaFefQcQ-eoVzH_0J7I-j3LE-U,4407
+aizen/plugins.py,sha256=V1hLPFand8tYEibdwY07k3Ky8n0ZpX9wtMp6Q6vjNqg,2623
+aizen/retry.py,sha256=3XXGOfhUnuzUeGuMuwhoPMdmh4w1_3vWkKEWgO-kdEQ,4985
+aizen/session.py,sha256=jRNFlCDIyK8au6HZFKVWypU5WUmfewuq629ic7i-UmU,4335
+aizen/tools.py,sha256=926qeogPm-YWwjLvh7aWfocOmkG0mbzg01nTUtXlZEA,39581
+aizen/utils.py,sha256=_1Rs8yBE0dlTOa-lPZM_UcQlieLcPkUFR1xZWXk55uI,12568
+aizen_ai_cli-2.2.2.dist-info/METADATA,sha256=KkV5cPl5Bmce7FrA8JUJhs8ppWorHW1sh8evGqs0jNA,12100
+aizen_ai_cli-2.2.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+aizen_ai_cli-2.2.2.dist-info/entry_points.txt,sha256=d_9Sa5GfuASiNgNAbTVGCUWI7ZONCXJhE-kcqU3b5QI,42
+aizen_ai_cli-2.2.2.dist-info/top_level.txt,sha256=enJCkUp4c9xiYl8hVbkEB2VhhFiLQOOPxmGXjIhqW0A,6
+aizen_ai_cli-2.2.2.dist-info/RECORD,,

aizen_ai_cli-2.2.2.dist-info/WHEEL

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

aizen_ai_cli-2.2.2.dist-info/entry_points.txt

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

aizen_ai_cli-2.2.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+aizen