abstractagent 0.2.0__py3-none-any.whl

abstractagent/tools/self_improve.py

@@ -0,0 +1,56 @@
+"""Self-improvement logging tool.
+
+This tool intentionally writes to a user-local JSONL file (not the source tree)
+so it works both in monorepo dev and in installed environments.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from abstractcore.tools import tool
+
+
+def _default_improvements_path() -> Path:
+    configured = os.getenv("ABSTRACTFRAMEWORK_IMPROVEMENTS_PATH")
+    if configured:
+        return Path(configured).expanduser()
+    return Path.home() / ".abstractframework" / "improvements.jsonl"
+
+
+@tool(
+    name="self_improve",
+    description="Log an improvement suggestion (JSONL) for later review and prioritization.",
+    when_to_use="When you notice a bug, UX issue, missing feature, or an idea that should be tracked for future work",
+)
+def self_improve(
+    suggestion: str,
+    target: str = "unknown",
+    category: str = "general",
+    tags: Optional[Dict[str, str]] = None,
+) -> str:
+    """Append a self-improvement entry to a local JSONL file."""
+    try:
+        out_path = _default_improvements_path()
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+
+        entry: Dict[str, Any] = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "category": category,
+            "target": target,
+            "suggestion": suggestion,
+            "tags": tags or {},
+            "cwd": os.getcwd(),
+        }
+
+        with out_path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+        return f"Logged improvement suggestion to {str(out_path)}"
+    except Exception as e:
+        return f"Error: {e}"
+

abstractagent/ui/__init__.py

@@ -0,0 +1,5 @@
+"""UI components for AbstractAgent."""
+
+from .question import QuestionUI, render_question, get_user_response
+
+__all__ = ["QuestionUI", "render_question", "get_user_response"]

abstractagent/ui/question.py

@@ -0,0 +1,197 @@
+"""Interactive question UI for agent-user interaction.
+
+Provides a clean terminal UI for:
+- Multiple choice questions
+- Free text input
+- Combined choice + free text
+"""
+
+import sys
+from typing import List, Optional, Dict, Any
+
+
+# ANSI color codes
+class Colors:
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    
+    CYAN = "\033[36m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    WHITE = "\033[37m"
+    
+    BG_BLUE = "\033[44m"
+    BG_CYAN = "\033[46m"
+
+
+def _supports_color() -> bool:
+    """Check if terminal supports colors."""
+    if not hasattr(sys.stdout, "isatty"):
+        return False
+    if not sys.stdout.isatty():
+        return False
+    return True
+
+
+def _c(text: str, *codes: str) -> str:
+    """Apply color codes if supported."""
+    if not _supports_color():
+        return text
+    return "".join(codes) + text + Colors.RESET
+
+
+class QuestionUI:
+    """Interactive question UI component."""
+    
+    def __init__(
+        self,
+        prompt: str,
+        choices: Optional[List[str]] = None,
+        allow_free_text: bool = True,
+    ):
+        self.prompt = prompt
+        self.choices = choices or []
+        self.allow_free_text = allow_free_text
+    
+    def render(self) -> None:
+        """Render the question UI to terminal."""
+        print()
+        print(_c("┌" + "─" * 58 + "┐", Colors.CYAN))
+        print(_c("│", Colors.CYAN) + _c(" 🤖 Agent Question", Colors.BOLD, Colors.YELLOW) + " " * 39 + _c("│", Colors.CYAN))
+        print(_c("├" + "─" * 58 + "┤", Colors.CYAN))
+        
+        # Word wrap the prompt
+        words = self.prompt.split()
+        lines = []
+        current_line = ""
+        for word in words:
+            if len(current_line) + len(word) + 1 <= 56:
+                current_line += (" " if current_line else "") + word
+            else:
+                if current_line:
+                    lines.append(current_line)
+                current_line = word
+        if current_line:
+            lines.append(current_line)
+        
+        for line in lines:
+            padding = 56 - len(line)
+            print(_c("│", Colors.CYAN) + f" {line}" + " " * padding + _c("│", Colors.CYAN))
+        
+        print(_c("├" + "─" * 58 + "┤", Colors.CYAN))
+        
+        # Render choices if any
+        if self.choices:
+            print(_c("│", Colors.CYAN) + _c(" Options:", Colors.DIM) + " " * 48 + _c("│", Colors.CYAN))
+            for i, choice in enumerate(self.choices, 1):
+                choice_text = f"  [{i}] {choice}"
+                if len(choice_text) > 56:
+                    choice_text = choice_text[:53] + "..."
+                padding = 56 - len(choice_text)
+                print(_c("│", Colors.CYAN) + _c(f" [{i}]", Colors.GREEN, Colors.BOLD) + f" {choice}" + " " * (padding - 4) + _c("│", Colors.CYAN))
+            
+            if self.allow_free_text:
+                print(_c("│", Colors.CYAN) + " " * 57 + _c("│", Colors.CYAN))
+                free_text = f"  [0] Type your own response..."
+                padding = 56 - len(free_text)
+                print(_c("│", Colors.CYAN) + _c("  [0]", Colors.MAGENTA, Colors.BOLD) + " Type your own response..." + " " * (padding - 5) + _c("│", Colors.CYAN))
+        
+        print(_c("└" + "─" * 58 + "┘", Colors.CYAN))
+        print()
+    
+    def get_input(self) -> str:
+        """Get user input with validation."""
+        while True:
+            if self.choices:
+                prompt_text = _c("Enter choice (1-" + str(len(self.choices)) + ") or 0 for custom: ", Colors.CYAN)
+            else:
+                prompt_text = _c("Your response: ", Colors.CYAN)
+            
+            try:
+                user_input = input(prompt_text).strip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                return ""
+            
+            if not user_input:
+                continue
+            
+            # Handle choice selection
+            if self.choices:
+                try:
+                    choice_num = int(user_input)
+                    if choice_num == 0 and self.allow_free_text:
+                        # Free text mode
+                        print()
+                        custom_input = input(_c("Type your response: ", Colors.MAGENTA)).strip()
+                        if custom_input:
+                            return custom_input
+                        continue
+                    elif 1 <= choice_num <= len(self.choices):
+                        return self.choices[choice_num - 1]
+                    else:
+                        print(_c(f"Please enter 1-{len(self.choices)}" + (" or 0" if self.allow_free_text else ""), Colors.YELLOW))
+                        continue
+                except ValueError:
+                    # Not a number - treat as free text if allowed
+                    if self.allow_free_text:
+                        return user_input
+                    print(_c("Please enter a number.", Colors.YELLOW))
+                    continue
+            else:
+                # No choices - just return the input
+                return user_input
+    
+    def ask(self) -> str:
+        """Render and get response in one call."""
+        self.render()
+        return self.get_input()
+
+
+def render_question(
+    prompt: str,
+    choices: Optional[List[str]] = None,
+    allow_free_text: bool = True,
+) -> None:
+    """Render a question UI without getting input."""
+    ui = QuestionUI(prompt, choices, allow_free_text)
+    ui.render()
+
+
+def get_user_response(
+    prompt: str,
+    choices: Optional[List[str]] = None,
+    allow_free_text: bool = True,
+) -> str:
+    """Show question UI and get user response.
+    
+    Args:
+        prompt: The question to ask
+        choices: Optional list of choices
+        allow_free_text: Whether to allow free text input (always True for option 0)
+    
+    Returns:
+        User's response string
+    """
+    ui = QuestionUI(prompt, choices, allow_free_text)
+    return ui.ask()
+
+
+# Async version for use with asyncio
+async def get_user_response_async(
+    prompt: str,
+    choices: Optional[List[str]] = None,
+    allow_free_text: bool = True,
+) -> str:
+    """Async version of get_user_response."""
+    import asyncio
+    
+    ui = QuestionUI(prompt, choices, allow_free_text)
+    ui.render()
+    
+    # Run input in executor to not block event loop
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, ui.get_input)

abstractagent-0.2.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: abstractagent
+Version: 0.2.0
+Summary: Agent implementations using AbstractRuntime and AbstractCore
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: abstractcore
+Requires-Dist: abstractruntime
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# AbstractAgent
+
+Agent implementations using AbstractRuntime and AbstractCore.
+
+## Features
+
+- **ReAct Agent**: Reason-Act-Observe loop with tool calling
+- **Async REPL**: Interactive agent with real-time step visibility
+- **Pause/Resume**: Durable agent state with interrupt/resume capability
+- **Ask User**: Agent can ask questions with multiple choice + free text
+- **Ledger Recording**: All tool calls recorded for auditability
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+### Simple (Factory)
+
+```python
+from abstractagent import create_react_agent
+
+# One-liner agent creation
+agent = create_react_agent()
+agent.start("List the files in the current directory")
+state = agent.run_to_completion()
+print(state.output["answer"])
+```
+
+### With Custom Tools
+
+```python
+from abstractagent import create_react_agent
+from abstractcore.tools import tool
+
+@tool(name="my_tool", description="My custom tool")
+def my_tool(query: str) -> str:
+    """My custom tool."""
+    return f"Result for {query}"
+
+agent = create_react_agent(tools=[my_tool])
+```
+
+### Full Control
+
+```python
+from abstractruntime.integrations.abstractcore import create_local_runtime
+from abstractagent import ReactAgent, list_files, read_file
+
+# Create runtime
+runtime = create_local_runtime(
+    provider="ollama",
+    model="qwen3:4b-instruct-2507-q4_K_M",
+)
+
+# Create agent with specific tools
+agent = ReactAgent(
+    runtime=runtime,
+    tools=[list_files, read_file],
+)
+
+agent.start("List the files in the current directory")
+state = agent.run_to_completion()
+print(state.output["answer"])
+```
+
+## State Persistence
+
+Resume agents across process restarts:
+
+```python
+agent = create_react_agent()
+agent.start("Long running task")
+
+# Save state before exit
+agent.save_state("agent_state.json")
+
+# ... process restarts ...
+
+# Load and resume
+agent = create_react_agent()
+agent.load_state("agent_state.json")
+state = agent.run_to_completion()
+
+# Cleanup
+agent.clear_state("agent_state.json")
+```
+
+## REPL Usage
+
+```bash
+# Start the ReAct agent REPL
+python -m abstractagent.repl --provider ollama --model qwen3:4b-instruct-2507-q4_K_M
+```
+
+## Architecture
+
+```
+AbstractAgent
+     │
+     ├── Uses AbstractRuntime for durable execution
+     │   - Workflows survive crashes
+     │   - Pause/resume capability
+     │   - Ledger tracks all actions (LLM calls, tool calls)
+     │
+     └── Uses AbstractCore for LLM/tools
+         - Provider-agnostic LLM calls
+         - Tool registration and execution
+         - Tool call parsing for all model architectures
+```
+
+## Available Tools
+
+- `list_files(path)` - List files and directories
+- `read_file(path)` - Read file contents
+- `search_files(pattern, path)` - Search for files matching a glob pattern
+- `execute_command(command)` - Execute a shell command (with safety restrictions)
+- `ask_user(question, choices)` - Ask the user a question (built-in)

abstractagent-0.2.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+abstractagent/__init__.py,sha256=-o1xKOyT3rhA67Iey2RCeZzU5SiFLB1mX4F2tAKH98Y,948
+abstractagent/repl.py,sha256=1p5Nz-Is7_VrQaNwknAGC6rNteKiog0EmL7S2Vs-CVU,17342
+abstractagent/adapters/__init__.py,sha256=yJnlyihixq71XseNzTVpOCYAGyDRu_ZJuT0qakUSpZQ,207
+abstractagent/adapters/codeact_runtime.py,sha256=au4rBkr_GCqaegO9a6MVvw0O3xb9GkyST11Pd1ti5ow,14993
+abstractagent/adapters/react_runtime.py,sha256=OaQzQVyumVLDa-IXu7AikKwdJ3Xcga0t099AfSQIDSs,14264
+abstractagent/agents/__init__.py,sha256=7KUOj0mSa3M9JJMcXKlmw4vKbAc4fwaKpsjd8yryhKc,395
+abstractagent/agents/base.py,sha256=r6psm20TVzzCvc3JG6Tp4pv-3iZ08ALK3XpCe6Gs_bE,13907
+abstractagent/agents/codeact.py,sha256=87eb-1E1rtAAkOf-Y9xRg4mKoiwEh6ovXunVgFgBh-8,6657
+abstractagent/agents/react.py,sha256=c-uhcgm9Zr5JQG8SSbBDItlILI8ayzSClYCKcV7Y_E8,6951
+abstractagent/logic/__init__.py,sha256=6nzStnUG4w5qcWYEGfiplT6p9YrunZurifPVJKo3cLQ,473
+abstractagent/logic/builtins.py,sha256=fJXSW5wXR4cbP8R51C18w190MoRHQmL9U4BytBWBmoc,858
+abstractagent/logic/codeact.py,sha256=uOk7rrP4JQv8_rHBhON8u0-XbZeNpBVwbzCqfn7y5-g,6267
+abstractagent/logic/react.py,sha256=ONHdcRWNBfTg32OImUPfWhz1V6rZUG1Njcb4ldyt5qo,4849
+abstractagent/logic/types.py,sha256=idLhxgBaN3LY7tDmwMNL9hgWCKM5P1BRNv5YYkXMy80,595
+abstractagent/sandbox/__init__.py,sha256=Vay_BJzmfMcf-cAUoapDbckCyhHGQHFzObVR98x2j3g,186
+abstractagent/sandbox/interface.py,sha256=DtL_RYaXgPojW-vUIgEPi_69sleSNQU-YCWrwZ_WSoI,462
+abstractagent/sandbox/local.py,sha256=mFQzFgec0qgJ8VNbB0ZjeZi58BgrIE0frMFsasKe3iI,2143
+abstractagent/tools/__init__.py,sha256=4Hh6lMiiwJe7yX5JSbKpdMC8K4spk2_uLpCpkyMejD0,1196
+abstractagent/tools/code_execution.py,sha256=rQBJXfTGdCxVSr7SqTH17mQ9ylImNDcT5R7_bBIvygA,1417
+abstractagent/tools/self_improve.py,sha256=yOtsa0iS5OxVPLpu3MN_fPxPTEMl3Qnm1GWYJHFsZe8,1732
+abstractagent/ui/__init__.py,sha256=YB27Z-kNKEW7mE7kjEc1tja3osnoBtJ9LFoKoNWp0pU,175
+abstractagent/ui/question.py,sha256=PUwVZICQTJWS66Yl14WeJCpvucD8gP83zpFnXKY3Rq0,6508
+abstractagent-0.2.0.dist-info/licenses/LICENSE,sha256=6rL4UIO5IdK59THf7fx0q6Hmxp5grSFi7-kWLcczseA,1083
+abstractagent-0.2.0.dist-info/METADATA,sha256=Bs-M5Qhk4Whto7usmkcDHUmTZnsPUfI2eIm31ql57XY,3258
+abstractagent-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractagent-0.2.0.dist-info/entry_points.txt,sha256=tEaR0KtY-chcgRTd6ZVkvsqqaDpw2rvi-1RFktHGczU,56
+abstractagent-0.2.0.dist-info/top_level.txt,sha256=cgtC3Vjz_piTAMmRkd73tbUxk2jPeG3IxMbo7JK3RTU,14
+abstractagent-0.2.0.dist-info/RECORD,,

abstractagent-0.2.0.dist-info/WHEEL

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

abstractagent-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+react-agent = abstractagent.repl:main

abstractagent-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2025 Laurent-Philippe Albou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
+

abstractagent-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+abstractagent