aizen-ai-cli 2.4.1__tar.gz → 2.4.2__tar.gz

aizen_ai_cli-2.4.2/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: aizen-ai-cli
+Version: 2.4.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: questionary>=2.0.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)
+
+Aizen is a powerful, asynchronous AI assistant that integrates seamlessly into your terminal workflow. It reads your code, edits files safely, runs commands, and provides real‑time, richly formatted assistance—all while keeping costs transparent and sessions persistent.
+
+## 🌟 Key Benefits
+
+- **Effortless Integration** — Operates directly in your terminal, preserving shell state across commands.
+- **Intelligent Editing** — Perform precise, color‑coded file edits with `edit_file`.
+- **Background Execution** — Run long‑running tasks asynchronously and retrieve results later.
+- **Cost‑Aware Usage** — Real‑time cost estimation for all major LLMs.
+- **Persistent Sessions** — Save and restore conversations with checkpoints.
+- **Rich Visual Feedback** — Stream responses with live previews and animated thought indicators.
+- **Extensible Architecture** — Custom plugins and project‑specific rules tailor Aizen to your workflow.
+- **Comprehensive Logging** — Rotating logs with optional verbose output for debugging.
+
+## 🚀 Core Features
+
+### Asynchronous Architecture
+- Fully asynchronous operations using `asyncio` and `AsyncOpenAI` for concurrent processing, parallel tool runs, and streaming.
+
+### Stateful Terminal Session
+- Environment variables and directory changes persist across interactions.
+
+### Rich Markdown Rendering
+- Full Markdown support with headers, code blocks, lists, and styling via Rich.
+
+### Surgical File Editing
+- Precise search‑and‑replace with color‑coded diff previews (`edit_file`).
+
+### Vision Support
+- Native image handling and encoding for Vision APIs (e.g., GPT‑4o, Claude 3.5 Sonnet).
+
+### Real‑Time Command Streaming
+- Background command execution with async streaming of stdout/stderr; use `run_command --background`.
+
+## 🎛️ Workflow Tools
+
+- **Background Tasks** — Run non‑blocking commands; monitor with `check_background_task`; cancel with `kill_background_task`.
+- **Session Persistence** — Powered by SQLite (`~/.aizen_sessions/aizen.db`), auto‑migrating older JSON sessions.
+- **Project‑Specific Rules** — Auto‑load `.aizen_rules` or `.cursorrules` for repo‑specific behavior.
+- **Smart Autocomplete** — TAB‑completion with `.gitignore` awareness and directory traversal.
+
+## 💰 Cost Tracking
+
+- Real‑time token counting for inputs and outputs.
+- Current cost estimate shown in the CLI status bar.
+- Supports Anthropic (Claude 3.5/3.7 Sonnet, Opus, Haiku), Google (Gemini 2.5 Pro/Flash), and OpenAI (GPT‑4o, o1, o3‑mini).
+
+## 📌 Session Management
+
+- `/checkpoint [name]` — Save conversation snapshots.
+- `/restore [name]` — Restore a previous checkpoint.
+
+## 📁 Structured Logging
+
+- Logs stored at `~/.aizen_logs/aizen.log` (rotated, 5 MB caps, 3 files).
+- Verbose flag mirrors output to console.
+
+## 📦 Publishing & Development
+
+- Use `publish.sh` to build and publish to PyPI, NPM, and PyInstaller binaries.

aizen_ai_cli-2.4.2/README.md

@@ -0,0 +1,63 @@
+# 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)
+
+Aizen is a powerful, asynchronous AI assistant that integrates seamlessly into your terminal workflow. It reads your code, edits files safely, runs commands, and provides real‑time, richly formatted assistance—all while keeping costs transparent and sessions persistent.
+
+## 🌟 Key Benefits
+
+- **Effortless Integration** — Operates directly in your terminal, preserving shell state across commands.
+- **Intelligent Editing** — Perform precise, color‑coded file edits with `edit_file`.
+- **Background Execution** — Run long‑running tasks asynchronously and retrieve results later.
+- **Cost‑Aware Usage** — Real‑time cost estimation for all major LLMs.
+- **Persistent Sessions** — Save and restore conversations with checkpoints.
+- **Rich Visual Feedback** — Stream responses with live previews and animated thought indicators.
+- **Extensible Architecture** — Custom plugins and project‑specific rules tailor Aizen to your workflow.
+- **Comprehensive Logging** — Rotating logs with optional verbose output for debugging.
+
+## 🚀 Core Features
+
+### Asynchronous Architecture
+- Fully asynchronous operations using `asyncio` and `AsyncOpenAI` for concurrent processing, parallel tool runs, and streaming.
+
+### Stateful Terminal Session
+- Environment variables and directory changes persist across interactions.
+
+### Rich Markdown Rendering
+- Full Markdown support with headers, code blocks, lists, and styling via Rich.
+
+### Surgical File Editing
+- Precise search‑and‑replace with color‑coded diff previews (`edit_file`).
+
+### Vision Support
+- Native image handling and encoding for Vision APIs (e.g., GPT‑4o, Claude 3.5 Sonnet).
+
+### Real‑Time Command Streaming
+- Background command execution with async streaming of stdout/stderr; use `run_command --background`.
+
+## 🎛️ Workflow Tools
+
+- **Background Tasks** — Run non‑blocking commands; monitor with `check_background_task`; cancel with `kill_background_task`.
+- **Session Persistence** — Powered by SQLite (`~/.aizen_sessions/aizen.db`), auto‑migrating older JSON sessions.
+- **Project‑Specific Rules** — Auto‑load `.aizen_rules` or `.cursorrules` for repo‑specific behavior.
+- **Smart Autocomplete** — TAB‑completion with `.gitignore` awareness and directory traversal.
+
+## 💰 Cost Tracking
+
+- Real‑time token counting for inputs and outputs.
+- Current cost estimate shown in the CLI status bar.
+- Supports Anthropic (Claude 3.5/3.7 Sonnet, Opus, Haiku), Google (Gemini 2.5 Pro/Flash), and OpenAI (GPT‑4o, o1, o3‑mini).
+
+## 📌 Session Management
+
+- `/checkpoint [name]` — Save conversation snapshots.
+- `/restore [name]` — Restore a previous checkpoint.
+
+## 📁 Structured Logging
+
+- Logs stored at `~/.aizen_logs/aizen.log` (rotated, 5 MB caps, 3 files).
+- Verbose flag mirrors output to console.
+
+## 📦 Publishing & Development
+
+- Use `publish.sh` to build and publish to PyPI, NPM, and PyInstaller binaries.

{aizen_ai_cli-2.4.1 → aizen_ai_cli-2.4.2}/aizen/agent.py

@@ -10,6 +10,7 @@ Extracted from main.py to enable:
 import asyncio
 import json
 import random
+import re
 from typing import Any
 
 from rich.live import Live
@@ -159,7 +160,11 @@ class AgentRunner:
                         full_content += delta.content
                         if full_content.strip():
                             try:
-                                display_content = f"**◆ AIZEN:** {full_content}"
+                                # Strip reasoning/thought tags for cleaner UI display
+                                cleaned_content = re.sub(r'<think>.*?(?:</think>|$)', '', full_content, flags=re.DOTALL)
+                                cleaned_content = re.sub(r'<\|channel>thought.*?(?:<channel\|>|$)', '', cleaned_content, flags=re.DOTALL)
+
+                                display_content = f"**◆ AIZEN:** {cleaned_content.strip()}"
                                 rendered = Markdown(display_content)
                                 live.update(rendered)
                             except Exception:
@@ -192,7 +197,7 @@ class AgentRunner:
                             tool_text.append(" ...", style=f"{Theme.MUTED}")
                             live.update(tool_text)
 
-        except Exception as e:
+        except Exception:
             # Re-raise — let the caller (main_loop) handle specific exception types
             raise
 

{aizen_ai_cli-2.4.1 → aizen_ai_cli-2.4.2}/aizen/commands.py

@@ -658,6 +658,10 @@ async def handle_slash_command(
                 console.print("[yellow]Commit aborted.[/yellow]\n")
                 return False
 
+            if final_msg is None:
+                console.print(f"  [{Theme.WARNING}]Commit aborted.[/{Theme.WARNING}]\n")
+                return False
+
             final_msg = final_msg.strip()
             if not final_msg:
                 console.print(f"  [{Theme.ERROR}]Error: Commit message cannot be empty. Aborted.[/{Theme.ERROR}]\n")

{aizen_ai_cli-2.4.1 → aizen_ai_cli-2.4.2}/aizen/config.py

@@ -20,7 +20,7 @@ logger = logging.getLogger("aizen")
 
 # Read version from installed package metadata (stays in sync with pyproject.toml).
 # Falls back to a hardcoded value only when running from source without installing.
-_FALLBACK_VERSION = "2.4.1"
+_FALLBACK_VERSION = "2.4.2"
 try:
     VERSION = _pkg_version("aizen-ai-cli")
 except PackageNotFoundError:

aizen_ai_cli-2.4.2/aizen/tools/commands.py

@@ -0,0 +1,279 @@
+"""
+Command execution tools: run_command, background task management.
+"""
+
+import os
+import re
+import subprocess
+import threading
+import time
+import uuid
+from typing import Any
+
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+
+from ..config import DANGEROUS_PATTERNS, SAFE_COMMAND_PREFIXES, Theme, console
+from ..logging_config import logger
+from .helpers import _ask_permission, terminal_lock
+
+# Global dictionary for tracking background tasks
+# task_id -> {"process": Popen, "stdout": list, "stderr": list, "command": str}
+background_tasks: dict[str, dict[str, Any]] = {}
+background_tasks_lock = threading.Lock()  # Protects background_tasks dict
+
+
+class PersistentTerminal:
+    """A stateful bash terminal session that persists across command executions."""
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.proc = None
+        self.marker = "===AIZEN_CMD_END==="
+        self.stdout_buf = []
+        self.stderr_buf = []
+
+    def _start(self):
+        self.proc = subprocess.Popen(
+            ["bash"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+            env=os.environ.copy()
+        )
+
+        def reader(pipe, buf):
+            for line in iter(pipe.readline, ''):
+                buf.append(line)
+
+        threading.Thread(target=reader, args=(self.proc.stdout, self.stdout_buf), daemon=True).start()
+        threading.Thread(target=reader, args=(self.proc.stderr, self.stderr_buf), daemon=True).start()
+
+    def run(self, command: str, timeout: int = 120) -> tuple[str, str, int, bool, str]:
+        """Runs a command and returns (stdout, stderr, exit_code, timeout_occurred, new_pwd)."""
+        with self.lock:
+            if self.proc is None or self.proc.poll() is not None:
+                self._start()
+
+            self.stdout_buf.clear()
+            self.stderr_buf.clear()
+
+            marker_str = f"{self.marker}_{uuid.uuid4().hex[:8]}"
+            
+            # The payload. We echo the exit code and the current working directory.
+            cmd_payload = f"{command}\n__aizen_exit=$?; echo \"{marker_str}:$__aizen_exit:$(pwd)\"\n"
+            
+            try:
+                self.proc.stdin.write(cmd_payload)
+                self.proc.stdin.flush()
+            except BrokenPipeError:
+                self._start()
+                self.proc.stdin.write(cmd_payload)
+                self.proc.stdin.flush()
+
+            start_time = time.time()
+            exit_code = 0
+            timeout_occurred = False
+            new_pwd = ""
+
+            with Live(
+                Text("  ▶ Running...", style="dim italic"),
+                console=console,
+                refresh_per_second=4,
+                transient=True,
+            ) as live:
+                while True:
+                    elapsed = time.time() - start_time
+                    if elapsed > timeout:
+                        timeout_occurred = True
+                        break
+
+                    if self.proc.poll() is not None:
+                        break
+
+                    out_str = "".join(self.stdout_buf)
+                    if marker_str in out_str:
+                        # Give a tiny bit of time for stderr reader to catch up
+                        time.sleep(0.05)
+                        break
+
+                    tail = "".join(self.stdout_buf[-15:])
+                    display = Text()
+                    display.append(f"  ▶ Running ({elapsed:.0f}s)\n", style="dim italic")
+                    display.append(tail.rstrip(), style="dim")
+                    live.update(display)
+
+                    time.sleep(0.1)
+
+            out_str = "".join(self.stdout_buf)
+            err_str = "".join(self.stderr_buf)
+
+            final_out = []
+            for line in out_str.splitlines():
+                if line.startswith(marker_str):
+                    parts = line.split(":", 2)
+                    if len(parts) >= 2:
+                        try:
+                            exit_code = int(parts[1])
+                        except ValueError:
+                            pass
+                    if len(parts) >= 3:
+                        new_pwd = parts[2].strip()
+                    break
+                final_out.append(line)
+
+            output = "\n".join(final_out)
+            stderr_output = err_str.strip()
+
+            if timeout_occurred:
+                self.proc.kill()
+                self.proc = None
+
+            return output, stderr_output, exit_code, timeout_occurred, new_pwd
+
+
+# Global persistent terminal instance
+_terminal = PersistentTerminal()
+
+
+def is_command_safe(command: str) -> bool:
+    """Check if a command is safe to auto-execute without confirmation."""
+    cmd_stripped = command.strip()
+
+    for pattern in DANGEROUS_PATTERNS:
+        if re.search(pattern, cmd_stripped):
+            return False
+
+    for safe in SAFE_COMMAND_PREFIXES:
+        if cmd_stripped == safe or cmd_stripped.startswith(safe + " "):
+            return True
+
+    return False
+
+
+def run_command_impl(command: str, auto_approve: bool = False, timeout: int = 120, background: bool = False) -> str:
+    """Execute a shell command with safety checks. Uses PersistentTerminal unless background=True."""
+    logger.debug("run_command: %s (timeout=%ds, background=%s)", command, timeout, background)
+
+    safe = is_command_safe(command)
+    if not safe:
+        console.print(
+            Panel(
+                f"[bold {Theme.ACCENT}]◆ AIZEN[/bold {Theme.ACCENT}] [{Theme.TEXT}]wants to run:[/{Theme.TEXT}]\n\n[bold {Theme.TEXT}]{command}[/bold {Theme.TEXT}]",
+                border_style=Theme.BORDER,
+            )
+        )
+        with terminal_lock:
+            if not _ask_permission("  ▸ Allow?", auto_approve):
+                return "User denied command execution."
+    elif safe:
+        console.print(f"  [dim]▶ {command}{' (background)' if background else ''}[/dim]")
+
+    try:
+        if background:
+            # For background tasks, use isolated Popen so we don't block the persistent terminal
+            proc = subprocess.Popen(
+                command,
+                shell=True,
+                text=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            task_id = f"bg_{uuid.uuid4().hex[:8]}"
+            task_info = {
+                "process": proc,
+                "stdout": [],
+                "stderr": [],
+                "command": command,
+                "start_time": time.time()
+            }
+            with background_tasks_lock:
+                background_tasks[task_id] = task_info
+
+            def stream_reader(pipe, dest_list):
+                for line in iter(pipe.readline, ''):
+                    dest_list.append(line)
+                pipe.close()
+
+            threading.Thread(target=stream_reader, args=(proc.stdout, task_info["stdout"]), daemon=True).start()
+            threading.Thread(target=stream_reader, args=(proc.stderr, task_info["stderr"]), daemon=True).start()
+
+            return f"Task started in background with ID: {task_id}"
+
+        # Foreground interactive commands use the stateful terminal
+        output, stderr_output, exit_code, timeout_occurred, new_pwd = _terminal.run(command, timeout)
+
+        # Sync python's working directory with bash's working directory
+        if new_pwd and os.path.exists(new_pwd) and new_pwd != os.getcwd():
+            try:
+                os.chdir(new_pwd)
+                logger.info("Synced python cwd with bash: %s", new_pwd)
+            except Exception as e:
+                logger.error("Failed to sync python cwd with bash: %s", e)
+
+        if timeout_occurred:
+            logger.warning("Command timed out after %ds: %s", timeout, command)
+            return f"Error: Command timed out after {timeout} seconds.\nPartial Output:\n{output}"
+
+        if stderr_output:
+            if output:
+                output += f"\nSTDERR:\n{stderr_output}"
+            else:
+                output = stderr_output
+        if exit_code != 0:
+            output += f"\n[Exit code: {exit_code}]"
+        
+        return output.strip() if output.strip() else f"Command completed (exit code {exit_code})"
+
+    except Exception as e:
+        logger.exception("Error executing command: %s", command)
+        return f"Error executing command: {e}"
+
+
+def check_background_task_impl(task_id: str) -> str:
+    """Checks the status of a background task and returns its recent output."""
+    with background_tasks_lock:
+        if task_id not in background_tasks:
+            return f"Error: No such background task '{task_id}'."
+        task = background_tasks[task_id]
+
+    proc = task["process"]
+
+    out_lines = list(task["stdout"])
+    err_lines = list(task["stderr"])
+
+    stdout_str = "".join(out_lines[-100:]).strip()
+    stderr_str = "".join(err_lines[-100:]).strip()
+
+    status = "RUNNING" if proc.poll() is None else f"FINISHED (Exit code {proc.returncode})"
+
+    result = f"Task: {task_id}\nCommand: {task['command']}\nStatus: {status}\n\n"
+    if stdout_str:
+        result += f"--- STDOUT (last 100 lines) ---\n{stdout_str}\n\n"
+    if stderr_str:
+        result += f"--- STDERR (last 100 lines) ---\n{stderr_str}\n"
+
+    # Cleanup if done
+    if proc.poll() is not None:
+        with background_tasks_lock:
+            background_tasks.pop(task_id, None)
+
+    return result.strip()
+
+
+def kill_background_task_impl(task_id: str) -> str:
+    """Kills a running background task."""
+    with background_tasks_lock:
+        if task_id not in background_tasks:
+            return f"Error: No such background task '{task_id}'."
+        task = background_tasks.pop(task_id)
+
+    proc = task["process"]
+
+    if proc.poll() is None:
+        proc.kill()
+        return f"Task {task_id} killed."
+    else:
+        return f"Task {task_id} was already finished."

{aizen_ai_cli-2.4.1 → aizen_ai_cli-2.4.2}/aizen/tools/dispatcher.py

@@ -147,8 +147,8 @@ tools = [
     {
         "type": "function",
         "function": {
-            "name": "run_command",
-            "description": "Executes a shell command. Safe read-only commands run automatically; destructive commands require user confirmation. Use the timeout parameter for long-running commands like builds or test suites.",
+            "name": "run_terminal_command",
+            "description": "Executes a shell command in a stateful, persistent bash session. Environment variables and working directory changes (cd) persist across calls. Use the timeout parameter for long-running commands like builds or test suites.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -162,7 +162,7 @@ tools = [
                     },
                     "background": {
                         "type": "boolean",
-                        "description": "If true, runs the command asynchronously in the background. Returns a task ID immediately.",
+                        "description": "If true, runs the command asynchronously in a separate isolated background process (not the persistent shell). Returns a task ID immediately.",
                     },
                 },
                 "required": ["command"],
@@ -374,7 +374,7 @@ def execute_tool(tool_call, auto_approve: bool = False) -> str:
         console.print(tool_label)
         return multi_replace_file_content(filepath, chunks, auto_approve=auto_approve)
 
-    elif func_name == "run_command":
+    elif func_name == "run_terminal_command":
         command = str(args.get("command", ""))
         timeout = int(args.get("timeout", 120))
         background = bool(args.get("background", False))

{aizen_ai_cli-2.4.1 → aizen_ai_cli-2.4.2}/aizen/utils.py

@@ -237,7 +237,7 @@ class BackupManager:
             logger.debug("Cleanup backups failed: %s", e)
 
 
-def truncate_output(text: str, max_chars: int = 4000) -> str:
+def truncate_output(text: str, max_chars: int = 100000) -> str:
     if len(text) <= max_chars:
         return text
     half = max_chars // 2

aizen_ai_cli-2.4.2/aizen_ai_cli.egg-info/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: aizen-ai-cli
+Version: 2.4.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: questionary>=2.0.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)
+
+Aizen is a powerful, asynchronous AI assistant that integrates seamlessly into your terminal workflow. It reads your code, edits files safely, runs commands, and provides real‑time, richly formatted assistance—all while keeping costs transparent and sessions persistent.
+
+## 🌟 Key Benefits
+
+- **Effortless Integration** — Operates directly in your terminal, preserving shell state across commands.
+- **Intelligent Editing** — Perform precise, color‑coded file edits with `edit_file`.
+- **Background Execution** — Run long‑running tasks asynchronously and retrieve results later.
+- **Cost‑Aware Usage** — Real‑time cost estimation for all major LLMs.
+- **Persistent Sessions** — Save and restore conversations with checkpoints.
+- **Rich Visual Feedback** — Stream responses with live previews and animated thought indicators.
+- **Extensible Architecture** — Custom plugins and project‑specific rules tailor Aizen to your workflow.
+- **Comprehensive Logging** — Rotating logs with optional verbose output for debugging.
+
+## 🚀 Core Features
+
+### Asynchronous Architecture
+- Fully asynchronous operations using `asyncio` and `AsyncOpenAI` for concurrent processing, parallel tool runs, and streaming.
+
+### Stateful Terminal Session
+- Environment variables and directory changes persist across interactions.
+
+### Rich Markdown Rendering
+- Full Markdown support with headers, code blocks, lists, and styling via Rich.
+
+### Surgical File Editing
+- Precise search‑and‑replace with color‑coded diff previews (`edit_file`).
+
+### Vision Support
+- Native image handling and encoding for Vision APIs (e.g., GPT‑4o, Claude 3.5 Sonnet).
+
+### Real‑Time Command Streaming
+- Background command execution with async streaming of stdout/stderr; use `run_command --background`.
+
+## 🎛️ Workflow Tools
+
+- **Background Tasks** — Run non‑blocking commands; monitor with `check_background_task`; cancel with `kill_background_task`.
+- **Session Persistence** — Powered by SQLite (`~/.aizen_sessions/aizen.db`), auto‑migrating older JSON sessions.
+- **Project‑Specific Rules** — Auto‑load `.aizen_rules` or `.cursorrules` for repo‑specific behavior.
+- **Smart Autocomplete** — TAB‑completion with `.gitignore` awareness and directory traversal.
+
+## 💰 Cost Tracking
+
+- Real‑time token counting for inputs and outputs.
+- Current cost estimate shown in the CLI status bar.
+- Supports Anthropic (Claude 3.5/3.7 Sonnet, Opus, Haiku), Google (Gemini 2.5 Pro/Flash), and OpenAI (GPT‑4o, o1, o3‑mini).
+
+## 📌 Session Management
+
+- `/checkpoint [name]` — Save conversation snapshots.
+- `/restore [name]` — Restore a previous checkpoint.
+
+## 📁 Structured Logging
+
+- Logs stored at `~/.aizen_logs/aizen.log` (rotated, 5 MB caps, 3 files).
+- Verbose flag mirrors output to console.
+
+## 📦 Publishing & Development
+
+- Use `publish.sh` to build and publish to PyPI, NPM, and PyInstaller binaries.

{aizen_ai_cli-2.4.1 → aizen_ai_cli-2.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aizen-ai-cli"
-version = "2.4.1"
+version = "2.4.2"
 description = "Aizen AI Agent — A professional-grade AI coding assistant for your terminal."
 readme = "README.md"
 license = {text = "MIT"}

{aizen_ai_cli-2.4.1 → aizen_ai_cli-2.4.2}/setup.py

@@ -10,7 +10,7 @@ def parse_requirements(filename):
 
 setup(
     name="aizen-ai-cli",
-    version="2.4.1",
+    version="2.4.2",
     description="Aizen AI Agent — A professional-grade AI coding assistant for your terminal.",
     packages=["aizen"],
     install_requires=parse_requirements("requirements.txt"),