aizen-ai-cli 2.2.5__tar.gz → 2.4.0__tar.gz

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aizen-ai-cli
-Version: 2.2.5
+Version: 2.4.0
 Summary: Aizen AI Agent — A professional-grade AI coding assistant for your terminal.
 Author: Irtaza Malik
 License: MIT
@@ -54,9 +54,12 @@ A helpful AI coding assistant you can use right in your terminal. Aizen reads yo
 - **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.
+- **Vision Support** — Attach images natively (e.g., `@mockup.png`) and Aizen will automatically encode them for Vision APIs (GPT-4o, Claude 3.5 Sonnet).
+- **Real-time Command Streaming** — Long-running shell commands stream their output live to the terminal instead of freezing with a spinner.
+- **Smart Context Pruning** — Automatically drops old, large file attachments first when hitting the context limit before resorting to LLM summarization.
 
 ### Tools
-Aizen has 9 built-in tools the AI can use:
+Aizen has 10 built-in tools the AI can use:
 
 | Tool | Description |
 |------|-------------|
@@ -70,6 +73,8 @@ Aizen has 9 built-in tools the AI can use:
 | `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`) |
+| `get_file_outline` | Extract AST outline of a Python file (classes, methods, docstrings) without blowing up the context window |
+| `web_search` | Search the web for current information, docs, or API references |
 
 ### Commands
 
@@ -93,9 +98,11 @@ Aizen has 9 built-in tools the AI can use:
 | `/export [file]` | Export conversation to a Markdown file |
 | `/config` | View current configuration |
 | `/mcp` | View configured MCP servers and their connection status |
+| `/auto [task]` | Enter a fully autonomous agentic loop to execute a complex task step-by-step |
 
 ### Safety & UX
 - **Command Safety** — Read-only commands (`ls`, `cat`, `git status`, etc.) auto-execute. Destructive commands (`rm`, `sudo`, etc.) always require confirmation.
+- **Autonomous Limits** — The `/auto` mode enforces a strict 25-step execution limit to prevent infinite loops and runaway costs.
 - **`--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.

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/README.md

@@ -14,9 +14,12 @@ A helpful AI coding assistant you can use right in your terminal. Aizen reads yo
 - **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.
+- **Vision Support** — Attach images natively (e.g., `@mockup.png`) and Aizen will automatically encode them for Vision APIs (GPT-4o, Claude 3.5 Sonnet).
+- **Real-time Command Streaming** — Long-running shell commands stream their output live to the terminal instead of freezing with a spinner.
+- **Smart Context Pruning** — Automatically drops old, large file attachments first when hitting the context limit before resorting to LLM summarization.
 
 ### Tools
-Aizen has 9 built-in tools the AI can use:
+Aizen has 10 built-in tools the AI can use:
 
 | Tool | Description |
 |------|-------------|
@@ -30,6 +33,8 @@ Aizen has 9 built-in tools the AI can use:
 | `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`) |
+| `get_file_outline` | Extract AST outline of a Python file (classes, methods, docstrings) without blowing up the context window |
+| `web_search` | Search the web for current information, docs, or API references |
 
 ### Commands
 
@@ -53,9 +58,11 @@ Aizen has 9 built-in tools the AI can use:
 | `/export [file]` | Export conversation to a Markdown file |
 | `/config` | View current configuration |
 | `/mcp` | View configured MCP servers and their connection status |
+| `/auto [task]` | Enter a fully autonomous agentic loop to execute a complex task step-by-step |
 
 ### Safety & UX
 - **Command Safety** — Read-only commands (`ls`, `cat`, `git status`, etc.) auto-execute. Destructive commands (`rm`, `sudo`, etc.) always require confirmation.
+- **Autonomous Limits** — The `/auto` mode enforces a strict 25-step execution limit to prevent infinite loops and runaway costs.
 - **`--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.

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/aizen/commands.py

@@ -44,6 +44,7 @@ SLASH_COMMANDS = [
     ("/mcp", "View configured MCP servers and their status"),
     ("/commit", "Auto-generate and commit changes"),
     ("/diff", "Show all uncommitted changes"),
+    ("/auto", "Enter autonomous agentic mode for a complex task"),
 ]
 
 # In-memory checkpoint storage for conversation branching
@@ -284,6 +285,10 @@ async def handle_slash_command(
         help_table.add_row("  🔀 /commit", "Auto-generate and commit changes")
         help_table.add_row("  📊 /diff", "Show all uncommitted changes")
 
+        # ── Agent ──
+        help_table.add_row(f"[bold {Theme.MUTED}]── Agent ──[/bold {Theme.MUTED}]", "")
+        help_table.add_row("  🤖 /auto [task]", "Enter autonomous mode for a complex task (max iterations apply)")
+
         # ── Shortcuts ──
         help_table.add_row(f"[bold {Theme.MUTED}]── Shortcuts ──[/bold {Theme.MUTED}]", "")
         help_table.add_row(f"  [{Theme.PINK}]@file / @url[/{Theme.PINK}]", "Attach file context or web URL")

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/aizen/config.py

@@ -4,7 +4,6 @@ import logging
 import os
 import shutil
 import ssl
-import sys
 import threading
 import time
 import urllib.error
@@ -21,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.2.5"
+_FALLBACK_VERSION = "2.4.0"
 try:
     VERSION = _pkg_version("aizen-ai-cli")
 except PackageNotFoundError:
@@ -83,6 +82,8 @@ DANGEROUS_PATTERNS = [
     r"\brm\s", r"\bsudo\b", r"\bchmod\b", r"\bchown\b", r"\bmkfs\b",
     r"\bdd\b", r":\(\)\{", r"\bkill\b", r"\bpkill\b", r"\bshutdown\b",
     r"\breboot\b", r">\s*/dev/", r"\bcurl\b.*\|\s*(ba)?sh",
+    r"\bmktemp\b.*>", r"\btruncate\b", r"\bmv\s+/(?!tmp)", r"chmod\s+777",
+    r"git\s+push\s+--force", r"\bdocker\s+run\b", r"\bpip\s+install\b", r"\bnpm\s+install\b",
     # Shell injection patterns
     r"`[^`]+`",           # Backtick command substitution
     r"\$\([^)]+\)",       # $() command substitution
@@ -209,13 +210,30 @@ def migrate_legacy_data():
 
 def load_config() -> dict:
     migrate_legacy_data()
+
+    config = {}
+    # Load global config
     if os.path.exists(CONFIG_PATH):
         try:
             with open(CONFIG_PATH) as f:
-                return json.load(f)
+                config = json.load(f)
         except Exception as e:
-            logger.debug("Failed to load config file: %s", e)
-    return {}
+            logger.debug("Failed to load global config file: %s", e)
+
+    # Merge local config if present
+    local_config_path = os.path.join(os.getcwd(), ".aizen_config.json")
+    if os.path.exists(local_config_path):
+        try:
+            with open(local_config_path) as f:
+                local_config = json.load(f)
+                # Merge local config keys (overriding global ones)
+                if isinstance(local_config, dict):
+                    config.update(local_config)
+                    console.print(f"{Theme.SYS} Local config loaded from [#d3fbff]{local_config_path}[/#d3fbff]")
+        except Exception as e:
+            logger.debug("Failed to load local config file: %s", e)
+
+    return config
 
 
 def get_mcp_servers(config: dict) -> dict:
@@ -252,8 +270,8 @@ def get_api_key(config: dict, reset: bool = False) -> str:
 
     key = getpass.getpass("API Key: ").strip()
     if not key:
-        console.print("[bold red]Error:[/bold red] API Key cannot be empty.")
-        sys.exit(1)
+        from .exceptions import APIKeyError
+        raise APIKeyError("API Key cannot be empty.")
 
     config["OPENROUTER_API_KEY"] = key
     save_config(config)

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/aizen/main.py

@@ -5,7 +5,9 @@ Aizen AI Agent — A professional-grade AI coding assistant for your terminal.
 
 import argparse
 import asyncio
+import base64
 import json
+import mimetypes
 import os
 import random
 import re
@@ -43,6 +45,7 @@ from .config import (
     set_active_model,
 )
 from .context import ContextManager
+from .exceptions import APIKeyError, SessionCorruptedError
 from .logging_config import logger, setup_logging
 from .mcp import MCPManager
 from .plugins import plugin_manager
@@ -81,6 +84,8 @@ def inject_file_context(user_input: str) -> str:
     if not matches and not context_blocks:
         return user_input
 
+    images = []
+
     for item in set(matches):
         if item.startswith("http://") or item.startswith("https://"):
             console.print(f"  [dim]🌐 Fetching: {item}[/dim]")
@@ -92,17 +97,28 @@ def inject_file_context(user_input: str) -> str:
                     f'<url_context url="{item}">\n{content}\n</url_context>'
                 )
         elif os.path.isfile(item):
-            try:
-                with open(item, encoding="utf-8", errors="ignore") as f:
-                    content = f.read()
-                context_blocks.append(
-                    f'<file_context path="{item}">\n{content}\n</file_context>'
-                )
-                console.print(f"  [dim]📎 Attached: {item}[/dim]")
-            except Exception as e:
-                console.print(
-                    f"  [dim yellow]⚠️  Failed to read {item}: {e}[/dim yellow]"
-                )
+            ext = os.path.splitext(item)[1].lower()
+            if ext in [".png", ".jpg", ".jpeg", ".webp", ".gif"]:
+                try:
+                    with open(item, "rb") as f:
+                        b64_img = base64.b64encode(f.read()).decode("utf-8")
+                    mime_type = mimetypes.guess_type(item)[0] or "image/png"
+                    images.append(f"data:{mime_type};base64,{b64_img}")
+                    console.print(f"  [dim]🖼️  Attached image: {item}[/dim]")
+                except Exception as e:
+                    console.print(f"  [dim yellow]⚠️  Failed to read image {item}: {e}[/dim yellow]")
+            else:
+                try:
+                    with open(item, encoding="utf-8", errors="ignore") as f:
+                        content = f.read()
+                    context_blocks.append(
+                        f'<file_context path="{item}">\n{content}\n</file_context>'
+                    )
+                    console.print(f"  [dim]📎 Attached: {item}[/dim]")
+                except Exception as e:
+                    console.print(
+                        f"  [dim yellow]⚠️  Failed to read {item}: {e}[/dim yellow]"
+                    )
         elif os.path.isdir(item):
             try:
                 tree_output = generate_directory_tree(item)
@@ -119,6 +135,13 @@ def inject_file_context(user_input: str) -> str:
 
     if context_blocks:
         user_input += "\n\n" + "\n".join(context_blocks)
+
+    if images:
+        content_list = [{"type": "text", "text": user_input}]
+        for img_url in images:
+            content_list.append({"type": "image_url", "image_url": {"url": img_url}})
+        return content_list
+
     return user_input
 
 
@@ -144,6 +167,12 @@ def parse_args():
         action="store_true",
         help="Enable verbose logging output to console.",
     )
+    parser.add_argument(
+        "--max-iterations",
+        type=int,
+        default=25,
+        help="Maximum iterations for autonomous mode (default: 25).",
+    )
     return parser.parse_args()
 
 @retry_with_backoff(max_retries=3, backoff_base=2.0)
@@ -189,6 +218,10 @@ async def main_loop():
     api_base = config.get("API_BASE_URL", "https://openrouter.ai/api/v1")
     auto_approve = args.yolo or config.get("auto_approve", False)
 
+    is_auto_mode = False
+    max_auto_iterations = getattr(args, "max_iterations", 25)
+    auto_iteration_count = 0
+
     client = AsyncOpenAI(base_url=api_base, api_key=api_key)
 
     token_tracker = TokenTracker()
@@ -242,10 +275,43 @@ async def main_loop():
         "scrollbar.button": f"bg:{Theme.ACCENT}",
     })
 
+    def get_bottom_toolbar():
+        # Get dynamic stats
+        cost = token_tracker.get_estimated_cost(get_active_model())
+        cost_str = f" (${cost:.3f})" if cost > 0 else ""
+        msgs = token_tracker.message_count
+        tokens = token_tracker.total_tokens
+        model = get_active_model()
+        ctx_pct = context_manager.usage_percent
+
+        # Color coding for context usage
+        if ctx_pct >= 85:
+            ctx_color = "fg:#f87171" # ERROR
+        elif ctx_pct >= 75:
+            ctx_color = "fg:#fbbf24" # WARNING
+        else:
+            ctx_color = "fg:#4ade80" # SUCCESS
+
+        return FormattedText([
+            ("bg:#1e1b2e fg:#6b7280", " ◈ "),
+            ("bg:#1e1b2e fg:#e2e8f0", f"{tokens:,} tokens"),
+            ("bg:#1e1b2e fg:#4ade80 bold", f"{cost_str}"),
+            ("bg:#1e1b2e fg:#4b5563", " │ "),
+            ("bg:#1e1b2e fg:#e2e8f0", f"{msgs}"),
+            ("bg:#1e1b2e fg:#6b7280", " msgs"),
+            ("bg:#1e1b2e fg:#4b5563", " │ "),
+            ("bg:#1e1b2e fg:#22d3ee", f"{model}"),
+            ("bg:#1e1b2e fg:#4b5563", " │ "),
+            ("bg:#1e1b2e fg:#6b7280", "ctx: "),
+            (f"bg:#1e1b2e {ctx_color} bold", f"{ctx_pct}%"),
+            ("bg:#1e1b2e", " "),
+        ])
+
     session: PromptSession = PromptSession(
         completer=AizenCompleter(),
         key_bindings=kb,
-        style=cyberpunk_style
+        style=cyberpunk_style,
+        bottom_toolbar=get_bottom_toolbar
     )
 
     messages = [{"role": "system", "content": build_system_prompt(config)}]
@@ -298,13 +364,32 @@ async def main_loop():
 
             # ── Slash Commands ──
             if user_input.strip().startswith("/"):
-                should_retry = await handle_slash_command(
-                    user_input.strip(), messages, token_tracker, mcp_manager, client
-                )
-                if should_retry and messages and messages[-1]["role"] == "user":
+                if user_input.strip().startswith("/auto"):
+                    task_desc = user_input.strip()[5:].strip()
+                    if not task_desc:
+                        console.print(f"  [{Theme.WARNING}]Please provide a task. Usage: /auto <task>[/{Theme.WARNING}]")
+                        continue
+                    auto_approve = True
+                    is_auto_mode = True
+                    auto_iteration_count = 0
+                    messages.append({
+                        "role": "user",
+                        "content": (
+                            f"AUTONOMOUS MODE INITIATED.\nTask: {task_desc}\n\n"
+                            "You are now in fully autonomous mode. Break the task into steps, execute them using your tools, "
+                            "verify the results, and do NOT stop to ask for permission. Keep running tools until the task is completely finished."
+                        )
+                    })
+                    console.print(f"  [{Theme.PRIMARY}]🤖 Autonomous mode engaged! YOLO is active.[/{Theme.PRIMARY}]\n")
                     pass  # Fall through to the agent loop
                 else:
-                    continue
+                    should_retry = await handle_slash_command(
+                        user_input.strip(), messages, token_tracker, mcp_manager, client
+                    )
+                    if should_retry and messages and messages[-1]["role"] == "user":
+                        pass  # Fall through to the agent loop
+                    else:
+                        continue
             else:
                 user_input = inject_file_context(user_input)
                 messages.append({"role": "user", "content": user_input})
@@ -318,42 +403,63 @@ async def main_loop():
             if warning:
                 console.print(f"[yellow]{warning}[/yellow]\n")
 
-            # ── Auto-compact if context is critically full (>90%) ──
-            if context_manager.needs_auto_compact() and len(messages) > 6:
-                console.print("[dim yellow]⚡ Auto-compacting conversation to stay within context limits...[/dim yellow]")
-                system_msg = messages[0]
-                recent = messages[-4:]
-                middle = messages[1:-4]
-                if middle:
-                    user_topics = [
-                        m["content"][:100]
-                        for m in middle
-                        if m["role"] == "user" and m.get("content")
-                    ]
-                    summary = (
-                        "Previous conversation summary: The user and assistant discussed "
-                        + "; ".join(user_topics[:5])
-                        + ". The assistant helped with these requests using code analysis and editing tools."
-                    )
-                    messages[:] = [
-                        system_msg,
-                        {"role": "user", "content": f"Previous conversation summary:\n{summary}"},
-                        {
-                            "role": "assistant",
-                            "content": "Understood. I have the context from our previous discussion. How can I continue helping?",
-                        },
-                    ] + recent
-                    console.print(
-                        f"[green]✓ Auto-compacted {len(middle)} messages into a summary.[/green]\n"
-                    )
-                    # Recalculate token usage after compaction
-                    estimated_total = context_manager.estimate_messages_tokens(
-                        messages, token_tracker.estimate_tokens
-                    )
-                    context_manager.update(estimated_total)
+            # ── Auto-compact if context is critically full ──
+            if context_manager.needs_auto_compact() and len(messages) > 4:
+                console.print("[dim yellow]⚡ Context limit reached. Attempting smart pruning...[/dim yellow]")
+                dropped_count = 0
+
+                # First pass: try semantic truncation (dropping file/url/dir context blocks)
+                for msg in messages[1:-2]:
+                    if msg["role"] == "user" and msg.get("content"):
+                        old_content = msg["content"]
+                        new_content = re.sub(r'<file_context path="[^"]+">.*?</file_context>', '[File context dropped]', old_content, flags=re.DOTALL)
+                        new_content = re.sub(r'<url_context url="[^"]+">.*?</url_context>', '[URL context dropped]', new_content, flags=re.DOTALL)
+                        new_content = re.sub(r'<directory_context path="[^"]+">.*?</directory_context>', '[Directory context dropped]', new_content, flags=re.DOTALL)
+                        new_content = re.sub(r'<command_context cmd="[^"]+">.*?</command_context>', '[Command context dropped]', new_content, flags=re.DOTALL)
+
+                        if old_content != new_content:
+                            msg["content"] = new_content
+                            dropped_count += 1
+
+                estimated_total = context_manager.estimate_messages_tokens(messages, token_tracker.estimate_tokens)
+                context_manager.update(estimated_total)
+
+                # Second pass: if still over threshold, do naive summarization
+                if context_manager.needs_auto_compact() and len(messages) > 6:
+                    console.print("[dim yellow]⚡ Context still full. Compacting older messages...[/dim yellow]")
+                    system_msg = messages[0]
+                    recent = messages[-4:]
+                    middle = messages[1:-4]
+                    if middle:
+                        user_topics = [m["content"][:100] for m in middle if m["role"] == "user" and m.get("content")]
+                        summary = "Previous conversation summary: The user and assistant discussed " + "; ".join(user_topics[:5]) + ". The assistant helped with these requests."
+                        messages[:] = [
+                            system_msg,
+                            {"role": "user", "content": f"Previous conversation summary:\n{summary}"},
+                            {"role": "assistant", "content": "Understood. I have the context. How can I continue helping?"},
+                        ] + recent
+                        console.print(f"[green]✓ Auto-compacted {len(middle)} messages into a summary.[/green]\n")
+                elif dropped_count > 0:
+                    console.print(f"[green]✓ Pruned attached contexts from {dropped_count} past messages to save space.[/green]\n")
+
+                estimated_total = context_manager.estimate_messages_tokens(messages, token_tracker.estimate_tokens)
+                context_manager.update(estimated_total)
 
             # ── Agent Loop ──────────────────────────────────────────────────
             while True:
+                if is_auto_mode:
+                    auto_iteration_count += 1
+                    if auto_iteration_count > max_auto_iterations:
+                        console.print(f"  [{Theme.WARNING}]⚠️  Autonomous mode reached iteration limit ({max_auto_iterations}). Exiting auto mode.[/{Theme.WARNING}]")
+                        is_auto_mode = False
+                        auto_approve = args.yolo or config.get("auto_approve", False)
+                        messages.append({
+                            "role": "user",
+                            "content": f"You have reached the maximum number of autonomous iterations ({max_auto_iterations}). Please provide a brief summary of what you have accomplished and what remains."
+                        })
+                        auto_iteration_count = 0
+                        # Continue to let it generate the summary
+
                 full_content = ""
                 accumulated_tool_calls = {}
 
@@ -369,7 +475,10 @@ async def main_loop():
                         "Synthesizing...",
                     ]
                 )
-                spinner_display = Spinner("dots2", text=Text(f" {spinner_label}", style=f"{Theme.MUTED} italic"), style=f"{Theme.PRIMARY} bold")
+                if is_auto_mode:
+                    spinner_display = Spinner("dots2", text=Text(f" [Step {auto_iteration_count}/{max_auto_iterations}] {spinner_label}", style=f"{Theme.MUTED} italic"), style=f"{Theme.PRIMARY} bold")
+                else:
+                    spinner_display = Spinner("dots2", text=Text(f" {spinner_label}", style=f"{Theme.MUTED} italic"), style=f"{Theme.PRIMARY} bold")
 
                 try:
                     with Live(
@@ -583,25 +692,25 @@ async def main_loop():
                         "content": truncate_output(result),
                     }
 
-                tool_results = await asyncio.gather(*[_exec_tool(tc) for tc in tool_calls_list])
+                tool_results = await asyncio.gather(
+                    *[_exec_tool(tc) for tc in tool_calls_list],
+                    return_exceptions=True,
+                )
+                # Handle individual tool failures gracefully
+                for i, result in enumerate(tool_results):
+                    if isinstance(result, Exception):
+                        logger.error("Tool execution failed: %s", result)
+                        tool_results[i] = {
+                            "role": "tool",
+                            "tool_call_id": tool_calls_list[i]["id"],
+                            "name": tool_calls_list[i]["function"]["name"],
+                            "content": f"Error: Tool execution failed — {type(result).__name__}: {result}",
+                        }
                 messages.extend(tool_results)
 
                 # Continue the loop — model processes tool results
 
-            # ── Footer ──
-            cost = token_tracker.get_estimated_cost(get_active_model())
-            cost_display = f" [bold {Theme.SUCCESS}](${cost:.3f})[/bold {Theme.SUCCESS}]" if cost > 0 else ""
-
-            console.print(
-                f"\n  [{Theme.DIM_BORDER}]╰─[/{Theme.DIM_BORDER}] "
-                f"[{Theme.MUTED}]◈[/{Theme.MUTED}] [{Theme.TEXT}]{token_tracker.total_tokens:,}[/{Theme.TEXT}][{Theme.MUTED}] tokens{cost_display}[/{Theme.MUTED}]"
-                f" [{Theme.DIM_BORDER}]│[/{Theme.DIM_BORDER}] "
-                f"[{Theme.TEXT}]{token_tracker.message_count}[/{Theme.TEXT}][{Theme.MUTED}] msgs[/{Theme.MUTED}]"
-                f" [{Theme.DIM_BORDER}]│[/{Theme.DIM_BORDER}] "
-                f"[{Theme.ACCENT}]{get_active_model()}[/{Theme.ACCENT}]"
-                f" [{Theme.DIM_BORDER}]│[/{Theme.DIM_BORDER}] "
-                f"{context_manager.get_footer_text()}\n"
-            )
+            # Footer is now handled by the persistent bottom_toolbar
 
         except (KeyboardInterrupt, EOFError):
             # Auto-save on interrupt
@@ -620,8 +729,18 @@ async def main_loop():
         except Exception as e:
             logger.exception("Unhandled error in main loop: %s", e)
             console.print(f"\n  [bold {Theme.ERROR}]✖ Error[/bold {Theme.ERROR}] [{Theme.TEXT}]{e}[/{Theme.TEXT}]")
+
 def main():
-    asyncio.run(main_loop())
+    try:
+        asyncio.run(main_loop())
+    except APIKeyError as e:
+        console.print(f"[bold red]API Key Error:[/bold red] {e}")
+        sys.exit(1)
+    except SessionCorruptedError as e:
+        console.print(f"[bold red]Session Error:[/bold red] {e}")
+        sys.exit(1)
+    except KeyboardInterrupt:
+        sys.exit(0)
 
 if __name__ == "__main__":
     main()

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/aizen/session.py

@@ -116,8 +116,9 @@ def load_session(name: str) -> list | None:
     if row:
         try:
             return json.loads(row[0])
-        except json.JSONDecodeError:
-            return None
+        except json.JSONDecodeError as e:
+            from .exceptions import SessionCorruptedError
+            raise SessionCorruptedError(f"Session '{name}' is corrupted: {e}")
     return None
 
 

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/aizen/tools.py

@@ -4,7 +4,9 @@ import fnmatch
 import json
 import os
 import re
+import shutil
 import subprocess
+import tempfile
 import threading
 import time
 import uuid
@@ -89,6 +91,9 @@ def _ask_permission(prompt_text: str, auto_approve: bool = False) -> bool:
 background_tasks: dict[str, dict[str, Any]] = {}
 background_tasks_lock = threading.Lock()  # Protects background_tasks dict
 
+_fuzzy_file_cache = None
+_fuzzy_file_cache_time = 0
+
 def fuzzy_match_file(filepath: str) -> str | None:
     """
     If the exact filepath does not exist, searches the current directory tree
@@ -97,16 +102,26 @@ def fuzzy_match_file(filepath: str) -> str | None:
     if not filepath or filepath.startswith("/") or filepath.startswith("~"):
         return None  # Only fuzzy match relative paths safely
 
-    ignore_patterns = load_gitignore_patterns()
-    all_files = []
+    global _fuzzy_file_cache, _fuzzy_file_cache_time
+    import time
+    now = time.time()
+
+    if _fuzzy_file_cache is not None and (now - _fuzzy_file_cache_time) < 10:
+        all_files = _fuzzy_file_cache
+    else:
+        ignore_patterns = load_gitignore_patterns()
+        all_files = []
+
+        # Collect all available files in the tree
+        for root, dirs, files in os.walk("."):
+            dirs[:] = [d for d in dirs if not should_ignore(os.path.join(root, d), ignore_patterns)]
+            for f in files:
+                path = os.path.relpath(os.path.join(root, f), ".")
+                if not should_ignore(path, ignore_patterns):
+                    all_files.append(path)
 
-    # Collect all available files in the tree
-    for root, dirs, files in os.walk("."):
-        dirs[:] = [d for d in dirs if not should_ignore(os.path.join(root, d), ignore_patterns)]
-        for f in files:
-            path = os.path.relpath(os.path.join(root, f), ".")
-            if not should_ignore(path, ignore_patterns):
-                all_files.append(path)
+        _fuzzy_file_cache = all_files
+        _fuzzy_file_cache_time = now
 
     # Use difflib to find the closest match
     matches = difflib.get_close_matches(filepath, all_files, n=1, cutoff=0.75)
@@ -366,6 +381,40 @@ tools = [
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_file_outline",
+            "description": "Extracts the abstract syntax tree (AST) outline of a Python file, showing classes, methods, and docstrings without the full implementation details. Useful for exploring large codebases.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "filepath": {
+                        "type": "string",
+                        "description": "Path to the Python file.",
+                    }
+                },
+                "required": ["filepath"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Search the web for current information. Use when you need up-to-date docs, error messages, or API references.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query",
+                    }
+                },
+                "required": ["query"],
+            },
+        },
+    },
 ]
 
 
@@ -507,6 +556,57 @@ def _check_git_dirty(filepath: str) -> None:
     except Exception:
         pass  # Not a git repo or git not installed
 
+def get_file_outline(filepath: str) -> str:
+    """Extract AST/regex outline of a Python or JS/TS file."""
+    try:
+        if not os.path.exists(filepath):
+            match = fuzzy_match_file(filepath)
+            if match:
+                filepath = match
+            else:
+                return f"Error: File '{filepath}' does not exist."
+
+        with open(filepath, encoding="utf-8", errors="ignore") as f:
+            content = f.read()
+
+        outline = [f"File: {filepath}\n"]
+
+        if filepath.endswith('.py'):
+            import ast
+            tree = ast.parse(content)
+            for node in tree.body:
+                if isinstance(node, ast.ClassDef):
+                    doc = ast.get_docstring(node)
+                    doc_str = f'    """{doc}"""\n' if doc else ''
+                    outline.append(f"class {node.name}:\n{doc_str}")
+                    for child in node.body:
+                        if isinstance(child, ast.FunctionDef):
+                            cdoc = ast.get_docstring(child)
+                            cdoc_str = f'        """{cdoc}"""\n' if cdoc else ''
+                            outline.append(f"    def {child.name}(...):\n{cdoc_str}")
+                elif isinstance(node, ast.FunctionDef):
+                    doc = ast.get_docstring(node)
+                    doc_str = f'    """{doc}"""\n' if doc else ''
+                    outline.append(f"def {node.name}(...):\n{doc_str}")
+        elif filepath.endswith(('.js', '.ts', '.jsx', '.tsx')):
+            import re
+            lines = content.splitlines()
+            for line in lines:
+                line_s = line.strip()
+                if re.match(r'^(export\s+)?(default\s+)?class\s+\w+', line_s):
+                    outline.append(line_s)
+                elif re.match(r'^(export\s+)?(default\s+)?(async\s+)?function\s+\w+', line_s):
+                    outline.append(line_s)
+                elif re.match(r'^(export\s+)?(const|let|var)\s+\w+\s*=\s*(async\s*)?(\([^)]*\)|[^=]+)\s*=>', line_s):
+                    outline.append(line_s)
+        else:
+            return f"Error: '{filepath}' language is not supported for outlining. Use read_file instead."
+
+        if len(outline) == 1:
+            return outline[0] + "\nNo classes or functions found."
+        return "\n".join(outline)
+    except Exception as e:
+        return f"Error getting file outline: {e}"
 
 def read_file(filepath: str) -> str:
     """Read file contents with safety checks for size and binary detection."""
@@ -627,6 +727,10 @@ def write_file_with_diff(filepath: str, content: str, auto_approve: bool = False
             syntax = Syntax(preview, lang, theme="monokai", line_numbers=True)
             console.print(syntax)
 
+        syntax_err = _validate_syntax(filepath, content)
+        if syntax_err:
+            return f"Error: The edit introduces a syntax or linting error and was aborted.\n{syntax_err}"
+
         # YOLO mode: skip confirmation
         with terminal_lock:
             if not _ask_permission("  ▸ Allow?", auto_approve):
@@ -651,6 +755,33 @@ def _validate_syntax(filepath: str, file_content: str) -> str | None:
             ast.parse(file_content)
         except SyntaxError as e:
             return f"SyntaxError in Python code: {e.msg} at line {e.lineno}, col {e.offset}"
+
+        # Additional Linting
+        if shutil.which("ruff"):
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as tmp:
+                tmp.write(file_content)
+                tmp_path = tmp.name
+            try:
+                result = subprocess.run(["ruff", "check", tmp_path], capture_output=True, text=True)
+                if result.returncode != 0:
+                    output = result.stdout.replace(tmp_path, os.path.basename(filepath))
+                    return f"Ruff Linting Error:\n{output}"
+            finally:
+                os.unlink(tmp_path)
+
+    elif filepath.endswith((".js", ".jsx", ".ts", ".tsx")):
+        if shutil.which("eslint"):
+            ext = os.path.splitext(filepath)[1]
+            with tempfile.NamedTemporaryFile(mode="w", suffix=ext, delete=False) as tmp:
+                tmp.write(file_content)
+                tmp_path = tmp.name
+            try:
+                result = subprocess.run(["eslint", "--no-warn-ignored", tmp_path], capture_output=True, text=True)
+                if result.returncode != 0:
+                    output = result.stdout.replace(tmp_path, os.path.basename(filepath))
+                    return f"ESLint Error:\n{output}"
+            finally:
+                os.unlink(tmp_path)
     return None
 
 def _fuzzy_find_block(file_lines: list[str], target_content: str, start_line: int, end_line: int) -> str | None:
@@ -1033,6 +1164,26 @@ def grep_search(query: str, path: str = ".", is_regex: bool = False) -> str:
         if not os.path.exists(path):
             return f"Error: Path '{path}' does not exist."
 
+        import shutil
+        import subprocess
+        if shutil.which("rg"):
+            args = ["rg", "-n", "-m", "50"]
+            if not is_regex:
+                args.append("-F")
+            args.extend(["-i", query, path])
+            try:
+                result = subprocess.run(args, capture_output=True, text=True, timeout=10)
+                if result.stdout:
+                    lines = result.stdout.splitlines()
+                    if len(lines) >= 50:
+                        lines.append("\n(Showing first 50 results)")
+                    return "\n".join(lines)
+                if result.returncode == 1:
+                    return "No matches found."
+            except Exception as e:
+                logger.debug("ripgrep failed, falling back to python search: %s", e)
+                # Fall back to pure Python if rg fails
+
         if is_regex:
             try:
                 pattern = re.compile(query, re.IGNORECASE)
@@ -1119,6 +1270,35 @@ def find_files(pattern: str, path: str = ".") -> str:
         return f"Error finding files: {e}"
 
 
+def web_search_impl(query: str) -> str:
+    import re
+    import urllib.parse
+    import urllib.request
+    url = "https://html.duckduckgo.com/html/?q=" + urllib.parse.quote(query)
+    try:
+        req = urllib.request.Request(
+            url,
+            headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'}
+        )
+        with urllib.request.urlopen(req, timeout=10) as response:
+            html = response.read().decode('utf-8', errors='ignore')
+
+        results = []
+        snippets = re.findall(r'<a class="result__snippet[^>]*href="([^"]+)"[^>]*>(.*?)</a>', html, re.IGNORECASE | re.DOTALL)
+
+        for href, text in snippets[:5]:
+            clean_href = urllib.parse.unquote(href.replace('//duckduckgo.com/l/?uddg=', '').split('&')[0])
+            clean_text = re.sub(r'<[^>]+>', '', text).strip()
+            results.append(f"URL: {clean_href}\nSnippet: {clean_text}\n")
+
+        if not results:
+            return "No results found or unable to parse search page."
+
+        return "\n".join(results)
+    except Exception as e:
+        return f"Error performing web search: {e}"
+
+
 # ─── Tool Dispatcher ───────────────────────────────────────────────────────────
 
 def execute_tool(tool_call, auto_approve: bool = False) -> str:
@@ -1226,6 +1406,12 @@ def execute_tool(tool_call, auto_approve: bool = False) -> str:
         console.print(tool_label)
         return truncate_output(grep_search(query, path, is_regex))
 
+    elif func_name == "web_search":
+        query = str(args.get("query", ""))
+        tool_label.append(f" → '{query or '?'}'", style="dim")
+        console.print(tool_label)
+        return truncate_output(web_search_impl(query))
+
     elif func_name == "find_files":
         pattern = str(args.get("pattern", ""))
         path = str(args.get("path", "."))
@@ -1233,6 +1419,12 @@ def execute_tool(tool_call, auto_approve: bool = False) -> str:
         console.print(tool_label)
         return truncate_output(find_files(pattern, path))
 
+    elif func_name == "get_file_outline":
+        filepath = str(args.get("filepath", ""))
+        tool_label.append(f" → {filepath or '?'}", style="dim")
+        console.print(tool_label)
+        return truncate_output(get_file_outline(filepath))
+
     else:
         # Check if a plugin handles this tool
         plugin_result = plugin_manager.execute_tool(tool_call, auto_approve=auto_approve)

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/aizen/utils.py

@@ -248,7 +248,15 @@ def truncate_output(text: str, max_chars: int = 4000) -> str:
     )
 
 
+_gitignore_cache = None
+_gitignore_cache_time = 0
+
 def load_gitignore_patterns() -> list:
+    global _gitignore_cache, _gitignore_cache_time
+    now = time.time()
+    if _gitignore_cache is not None and (now - _gitignore_cache_time) < 5:
+        return _gitignore_cache
+
     patterns = [
         ".git/", "node_modules/", "__pycache__/", "venv/", ".env",
         "dist/", "build/", "*.egg-info/", ".DS_Store",
@@ -262,6 +270,9 @@ def load_gitignore_patterns() -> list:
                         patterns.append(line)
         except Exception as e:
             logger.debug("Failed to load .gitignore: %s", e)
+
+    _gitignore_cache = patterns
+    _gitignore_cache_time = now
     return patterns
 
 

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/aizen_ai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aizen-ai-cli
-Version: 2.2.5
+Version: 2.4.0
 Summary: Aizen AI Agent — A professional-grade AI coding assistant for your terminal.
 Author: Irtaza Malik
 License: MIT
@@ -54,9 +54,12 @@ A helpful AI coding assistant you can use right in your terminal. Aizen reads yo
 - **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.
+- **Vision Support** — Attach images natively (e.g., `@mockup.png`) and Aizen will automatically encode them for Vision APIs (GPT-4o, Claude 3.5 Sonnet).
+- **Real-time Command Streaming** — Long-running shell commands stream their output live to the terminal instead of freezing with a spinner.
+- **Smart Context Pruning** — Automatically drops old, large file attachments first when hitting the context limit before resorting to LLM summarization.
 
 ### Tools
-Aizen has 9 built-in tools the AI can use:
+Aizen has 10 built-in tools the AI can use:
 
 | Tool | Description |
 |------|-------------|
@@ -70,6 +73,8 @@ Aizen has 9 built-in tools the AI can use:
 | `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`) |
+| `get_file_outline` | Extract AST outline of a Python file (classes, methods, docstrings) without blowing up the context window |
+| `web_search` | Search the web for current information, docs, or API references |
 
 ### Commands
 
@@ -93,9 +98,11 @@ Aizen has 9 built-in tools the AI can use:
 | `/export [file]` | Export conversation to a Markdown file |
 | `/config` | View current configuration |
 | `/mcp` | View configured MCP servers and their connection status |
+| `/auto [task]` | Enter a fully autonomous agentic loop to execute a complex task step-by-step |
 
 ### Safety & UX
 - **Command Safety** — Read-only commands (`ls`, `cat`, `git status`, etc.) auto-execute. Destructive commands (`rm`, `sudo`, etc.) always require confirmation.
+- **Autonomous Limits** — The `/auto` mode enforces a strict 25-step execution limit to prevent infinite loops and runaway costs.
 - **`--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.

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/pyproject.toml

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

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/setup.py

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

{aizen_ai_cli-2.2.5 → aizen_ai_cli-2.4.0}/tests/test_tools.py

@@ -153,15 +153,15 @@ class TestWriteFile:
 
     def test_write_creates_parent_dirs(self, tmp_dir):
         filepath = os.path.join(tmp_dir, "deep", "nested", "file.py")
-        result = write_file_with_diff(filepath, "content\n", auto_approve=True)
+        result = write_file_with_diff(filepath, "print('content')\n", auto_approve=True)
         assert "✓" in result
         assert os.path.exists(filepath)
 
     def test_write_overwrite_existing(self, sample_file):
-        result = write_file_with_diff(sample_file, "new content\n", auto_approve=True)
+        result = write_file_with_diff(sample_file, "print('new content')\n", auto_approve=True)
         assert "✓" in result
         with open(sample_file) as f:
-            assert f.read() == "new content\n"
+            assert f.read() == "print('new content')\n"
 
     def test_write_no_changes(self, sample_file):
         with open(sample_file) as f: