opalacoder 0.1.0__py3-none-any.whl

opalacoder/vcs.py

@@ -0,0 +1,254 @@
+"""Version Control System (VCS) strategies for OpalaCoder."""
+
+import os
+import subprocess
+from abc import ABC, abstractmethod
+from typing import List, Callable
+from agenticblocks.core.function_block import as_tool
+
+from . import terminal as T
+from .tools import AGENT_PROGRESS, _preview, get_project_path
+
+# ─── Base Strategy ────────────────────────────────────────────────────────────
+
+class VersionControlStrategy(ABC):
+    def __init__(self, project_path: str):
+        self.project_path = os.path.abspath(project_path)
+
+    @abstractmethod
+    def setup(self):
+        """Initialize VCS environment (e.g. create shadow git, gitignore)."""
+        pass
+
+    @abstractmethod
+    def pre_run(self, context_msg: str):
+        """Called before the agent starts executing its plan."""
+        pass
+
+    @abstractmethod
+    def post_run(self, success: bool, msg: str = ""):
+        """Called after the agent finishes its execution."""
+        pass
+
+    @abstractmethod
+    def get_tools(self) -> List[Callable]:
+        """Return a list of git tools available to the agent."""
+        pass
+
+    @abstractmethod
+    def manual_commit(self, message: str) -> tuple[bool, str]:
+        """Manually commit changes to the VCS."""
+        pass
+
+    @abstractmethod
+    def undo_last(self) -> tuple[bool, str]:
+        """Undo the last change in the VCS."""
+        pass
+
+
+# ─── Shadow Git Helper ────────────────────────────────────────────────────────
+
+def _run_shadow_git(command: str) -> subprocess.CompletedProcess:
+    """Run a Git command using the internal shadow git directory."""
+    project_path = get_project_path()
+    shadow_dir = os.path.join(project_path, ".opalacoder", ".git")
+    
+    # Ensure git dir config is passed
+    full_cmd = f"git --git-dir={shadow_dir} --work-tree={project_path} {command}"
+    
+    return subprocess.run(
+        full_cmd,
+        shell=True,
+        capture_output=True,
+        text=True,
+        cwd=project_path
+    )
+
+def _init_shadow_git(project_path: str):
+    """Initialize the shadow git repository if it doesn't exist."""
+    shadow_base = os.path.join(project_path, ".opalacoder")
+    shadow_dir = os.path.join(shadow_base, ".git")
+    gitignore_path = os.path.join(shadow_base, ".gitignore")
+    
+    os.makedirs(shadow_base, exist_ok=True)
+    
+    if not os.path.exists(shadow_dir):
+        # Init repo
+        cmd = f"git --git-dir={shadow_dir} --work-tree={project_path} init"
+        subprocess.run(cmd, shell=True, capture_output=True, cwd=project_path)
+        
+        # Configure excludes file
+        if not os.path.exists(gitignore_path):
+            with open(gitignore_path, "w", encoding="utf-8") as f:
+                f.write(".env\nnode_modules/\n__pycache__/\n.venv/\n")
+                
+        cmd_exclude = f"git --git-dir={shadow_dir} --work-tree={project_path} config core.excludesFile {gitignore_path}"
+        subprocess.run(cmd_exclude, shell=True, capture_output=True, cwd=project_path)
+        
+        # Initial commit
+        _run_shadow_git("add .")
+        _run_shadow_git("commit -m 'Initial checkpoint (Auto)'")
+
+def _auto_checkpoint(message: str):
+    """Automatically create a checkpoint in the shadow git."""
+    _run_shadow_git("add .")
+    res = _run_shadow_git(f"commit -m '{message}'")
+    return res.returncode == 0
+
+
+# ─── Agent Git Tools ──────────────────────────────────────────────────────────
+
+@as_tool(name="git_status", description="Get the status of the internal version control. Shows modified/added files.")
+def git_status() -> str:
+    AGENT_PROGRESS.update("git_status")
+    res = _run_shadow_git("status -s")
+    return res.stdout if res.stdout.strip() else "Working tree clean."
+
+@as_tool(name="git_diff", description="Get the diff of the internal version control to see exact code changes.")
+def git_diff() -> str:
+    AGENT_PROGRESS.update("git_diff")
+    res = _run_shadow_git("diff")
+    return res.stdout if res.stdout.strip() else "No changes."
+
+@as_tool(name="git_commit", description="Commit all current changes to the internal version control. Use this to save milestones.")
+def git_commit(message: str) -> str:
+    AGENT_PROGRESS.update("git_commit", _preview(message))
+    _run_shadow_git("add .")
+    res = _run_shadow_git(f'commit -m "{message}"')
+    if res.returncode == 0:
+        return f"Successfully committed: {message}"
+    return f"Failed to commit or nothing to commit. Stderr: {res.stderr}"
+
+
+# ─── Concrete Strategies ──────────────────────────────────────────────────────
+
+class AutoGitStrategy(VersionControlStrategy):
+    """Deterministic mode: Shadow Git initialized, pre/post checkpoints enforced, NO tools given to agent."""
+    
+    def setup(self):
+        _init_shadow_git(self.project_path)
+        T.info("Modo Auto VCS: Repositório interno inicializado/verificado.")
+
+    def pre_run(self, context_msg: str):
+        _auto_checkpoint("Pre-run checkpoint: Before executing plan")
+        
+    def post_run(self, success: bool, msg: str = ""):
+        status = "Success" if success else "Failed"
+        _auto_checkpoint(f"Post-run checkpoint: {status}. {msg}")
+
+    def get_tools(self) -> List[Callable]:
+        return []  # No tools for the agent in auto mode
+
+    def manual_commit(self, message: str) -> tuple[bool, str]:
+        _run_shadow_git("add .")
+        res = _run_shadow_git(f"commit -m '{message}'")
+        if res.returncode == 0:
+            return True, "Committed."
+        return False, res.stderr
+
+    def undo_last(self) -> tuple[bool, str]:
+        res = _run_shadow_git("rev-parse HEAD~1")
+        if res.returncode != 0:
+            return False, "Cannot undo. No previous checkpoints."
+        _run_shadow_git("reset --hard HEAD~1")
+        _run_shadow_git("clean -fd")
+        return True, "Last change undone."
+
+
+class HybridGitStrategy(VersionControlStrategy):
+    """Hybrid mode: Shadow Git initialized, agent has tools, orchestrator ensures safety checkpoints."""
+    
+    def setup(self):
+        _init_shadow_git(self.project_path)
+        T.info("Modo Hybrid VCS: Repositório interno pronto. Agente tem ferramentas de Git.")
+
+    def pre_run(self, context_msg: str):
+        _auto_checkpoint("Pre-run checkpoint: Before executing plan")
+        
+    def post_run(self, success: bool, msg: str = ""):
+        status = "Success" if success else "Failed"
+        _auto_checkpoint(f"Post-run checkpoint: {status}. {msg}")
+
+    def get_tools(self) -> List[Callable]:
+        return [git_status, git_diff, git_commit]
+
+    def manual_commit(self, message: str) -> tuple[bool, str]:
+        _run_shadow_git("add .")
+        res = _run_shadow_git(f"commit -m '{message}'")
+        if res.returncode == 0:
+            return True, "Committed."
+        return False, res.stderr
+
+    def undo_last(self) -> tuple[bool, str]:
+        res = _run_shadow_git("rev-parse HEAD~1")
+        if res.returncode != 0:
+            return False, "Cannot undo. No previous checkpoints."
+        _run_shadow_git("reset --hard HEAD~1")
+        _run_shadow_git("clean -fd")
+        return True, "Last change undone."
+
+
+class AgentDrivenGitStrategy(VersionControlStrategy):
+    """Agent-driven mode: Orchestrator does nothing automatically. Agent gets tools and decides when to use them."""
+    
+    def setup(self):
+        _init_shadow_git(self.project_path)
+        T.info("Modo Agent-Driven VCS: Agente tem controle total sobre o repositório interno.")
+
+    def pre_run(self, context_msg: str):
+        pass
+        
+    def post_run(self, success: bool, msg: str = ""):
+        pass
+
+    def get_tools(self) -> List[Callable]:
+        return [git_status, git_diff, git_commit]
+
+    def manual_commit(self, message: str) -> tuple[bool, str]:
+        _run_shadow_git("add .")
+        res = _run_shadow_git(f"commit -m '{message}'")
+        if res.returncode == 0:
+            return True, "Committed."
+        return False, res.stderr
+
+    def undo_last(self) -> tuple[bool, str]:
+        res = _run_shadow_git("rev-parse HEAD~1")
+        if res.returncode != 0:
+            return False, "Cannot undo. No previous checkpoints."
+        _run_shadow_git("reset --hard HEAD~1")
+        _run_shadow_git("clean -fd")
+        return True, "Last change undone."
+
+
+class NoGitStrategy(VersionControlStrategy):
+    """Null strategy: No version control at all."""
+    
+    def setup(self):
+        pass
+
+    def pre_run(self, context_msg: str):
+        pass
+        
+    def post_run(self, success: bool, msg: str = ""):
+        pass
+
+    def get_tools(self) -> List[Callable]:
+        return []
+
+    def manual_commit(self, message: str) -> tuple[bool, str]:
+        return False, "VCS is disabled."
+
+    def undo_last(self) -> tuple[bool, str]:
+        return False, "VCS is disabled."
+
+
+def get_vcs_strategy(strategy_name: str, project_path: str) -> VersionControlStrategy:
+    """Factory method to get the selected strategy."""
+    strategies = {
+        "auto": AutoGitStrategy,
+        "hybrid": HybridGitStrategy,
+        "agent_driven": AgentDrivenGitStrategy,
+        "none": NoGitStrategy
+    }
+    klass = strategies.get(strategy_name.lower(), HybridGitStrategy)
+    return klass(project_path)

opalacoder-0.1.0.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: opalacoder
+Version: 0.1.0
+Summary: Autonomous coding agent with interactive planning and modular execution
+Project-URL: Homepage, https://github.com/gilzamir/OpalaCoder
+Project-URL: Bug Tracker, https://github.com/gilzamir/OpalaCoder/issues
+Author-email: Gil Zamir <gilzamir@example.com>
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: agenticblocks-io
+Requires-Dist: instructor>=1.15.1
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Description-Content-Type: text/markdown
+
+# OpalaCoder
+
+**OpalaCoder** is an autonomous coding agent with interactive planning, modular execution, and persistent project memory. It is designed to work well with small and less autonomous models while maintaining the feel of a fully autonomous agent. It is built using the **AgenticBlocks.IO** framework.
+
+---
+
+## Features
+
+### Project-Centric Context Management
+OpalaCoder centers around **projects** rather than transient chat sessions. Every interaction happens within a named project with a fixed filesystem path. This anchors the LLM context, loads only project-relevant skills, scopes all file and terminal operations, and persists history effectively for both small local models and large hosted APIs.
+
+### Advanced Semantic Router (Chain of Thought)
+Uses an LLM for semantic routing with internal reasoning (Chain of Thought). It translates user demands to English internally, correctly deduces the intent, and seamlessly routes execution even for multilingual commands, injecting only the necessary context from specific **Skills** (`skills/*.md`).
+
+### Dynamic Model Selection (Double Inference Architecture)
+OpalaCoder dynamically evaluates task complexity. For trivial tasks, it uses a fast default model (e.g., `ollama/mistral-nemo`). If the task requires architectural refactoring or advanced complex logic, it automatically falls back to a more powerful alternative model configured via API keys.
+
+### Interactive Planning
+The agent receives a natural language demand, generates a high-level landscape plan, and enters a refinement loop with the user until the plan is approved. The approved plan is then automatically decomposed into executable sub-steps (subplans).
+
+### Execution with Retry & Strategy Routing
+OpalaCoder delegates orchestration to specialized strategies. Small models use a deterministic execution pipeline (DAG), while capable models can use a fully autonomous agent loop. If a sub-step fails, the agent retries (up to a configurable limit) by injecting the previous error into the context for self-correction.
+
+### Execution Modes
+
+| Mode   | Behavior |
+|--------|---------------|
+| `plan` | Generates a plan and asks for user approval before executing (default) |
+| `auto` | Executes everything without interruptions — ideal for automated pipelines |
+| `edit` | Requests user confirmation only for sensitive operations (file creation/deletion, network calls, etc.) |
+
+### Persistent Projects and CLI Commands
+Each execution belongs to a named project with continuous memory. During the chat with OpalaCoder, you can interact with the state manager using native commands:
+- `/help` or `/h`: Shows available commands.
+- `/clear`: Clears the memory and history of the current project.
+- `/rename <new_name>`: Renames the active project.
+- `/list`: Lists all projects saved in SQLite.
+- `/load <name>` and `/delete <name>`: Loads or deletes old projects. (Deleting also asks to delete the project directory).
+- `/skills`: Lists available skills and highlights the active ones for the project.
+- `/addskill <name>` and `/rmskill <name>`: Adds or removes specific skills for the current project.
+- `/undo`: Reverts the last change made by the agent via internal shadow VCS.
+- `/commit <msg>`: Forces a commit to the local shadow git control.
+- `/exit` or `/quit`: Exits the application.
+
+### Shadow Git (VCS)
+Every project comes with an isolated "Shadow Git" (`.opalacoder/.git`) that automatically checkpoints the codebase before and after execution. This allows for safe iteration without muddying the user's main git repository, and enables the `/undo` command.
+
+### Elegant Terminal
+Formatted output with [Rich](https://github.com/Texel-io/rich): banners, progress spinners, plan panels, per-subplan status tables, and highlighted error reports.
+
+### Modular Architecture
+The code is divided into independent, easy-to-debug modules:
+
+```text
+opalacoder/
+├── config.py       Global settings (model, retries, mode, db, VCS)
+├── terminal.py     Rich output (banners, spinners, panels, tables)
+├── project.py      SQLite project management and state
+├── vcs.py          Internal shadow Git strategies (auto, hybrid, agent-driven)
+├── agents.py       LLM agent factories
+├── planner.py      Pipeline: panorama → refinement → decomposition
+├── orchestrator.py Strategy-based execution (deterministic vs autonomous)
+└── cli.py          Argparse + project bootstrap + REPL
+```
+
+---
+
+## Requirements
+
+- Python 3.11+
+- [agenticblocks](https://github.com/gilzamir/agenticblocks) installed in the virtual environment
+- [Rich](https://github.com/Texel-io/rich): `pip install rich`
+- An accessible LLM server (e.g., [Ollama](https://ollama.com) with `mistral-nemo`, or any model supported by [litellm](https://docs.litellm.ai))
+
+---
+
+## Installation
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd OpalaCoder
+
+# Create and activate the virtual environment
+python -m venv .env
+source .env/bin/activate          # Linux/macOS
+# .env\Scripts\activate           # Windows
+
+# Install the dependencies
+pip install -r requirements.txt
+```
+
+### Environment Variables (Optional)
+
+Create a `.env` file in the project root to override defaults:
+
+```env
+# Default LLM model (any litellm supported string)
+OPALA_MODEL=ollama/mistral-nemo
+```
+
+---
+
+## How to Run
+
+```bash
+# Activate the virtual environment
+source .env/bin/activate
+
+# Default execution (plan mode)
+python main.py
+
+# Choose execution mode
+python main.py --mode auto
+python main.py --mode plan
+python main.py --mode edit
+
+# Use another model
+python main.py --model ollama/llama3
+
+# Custom database path
+python main.py --db /path/to/projects.db
+
+# Show version
+python main.py --version
+
+# Help
+python main.py --help
+```
+
+---
+
+## Project Flow
+
+```text
+1. Banner + Mode Selection
+       ↓
+2. Project Configuration
+   ├── New Project   → Name, Path, Description -> LLM selects skills
+   └── Existing      → Load context and skills
+       ↓
+3. User enters demand
+       ↓
+4. Agent generates landscape (high-level plan)
+       ↓
+5. Refinement loop (plan/edit modes)
+   ├── User approves → proceeds
+   └── User suggests changes → agent refines and loops back to step 5
+       ↓
+6. Decomposition into subplans (SP-1, SP-2, …)
+       ↓
+7. Sequential execution by dependency
+   └── For each subplan:
+       ├── Pre-run VCS checkpoint
+       ├── Executes generated code (AgenticBlocks WorkflowGraph)
+       ├── Success → Next subplan
+       └── Failure → Retry up to max_retries, then report error
+       ├── Post-run VCS checkpoint
+       ↓
+8. Aggregation: Final synthesized result of the operation
+       ↓
+9. Result displayed + project saved
+```
+
+---
+
+## Advanced Configuration
+
+### Build & Test Commands
+Run tests in the `tests` directory after implementing a new feature:
+
+```bash
+python -m pytest
+```
+
+### Change the Default Model
+
+Edit `opalacoder/config.py`:
+
+```python
+DEFAULT_MODEL = "ollama/mistral-nemo"  # change here
+```
+
+Or use the environment variable `OPALA_MODEL`.
+
+### Sensitive Operations
+
+In `opalacoder/config.py`:
+
+```python
+SENSITIVE_OPS = {
+    "write_file", "delete_file", "run_shell",
+    "send_network_request", "create_user", "delete_user",
+    # add keywords here for operations that require confirmation in edit mode
+}
+```
+
+---
+
+## Security
+
+- The `edit` mode requires explicit confirmation for operations affecting the filesystem, network, or user accounts.
+- Generated code is executed locally. For greater isolation, the `CodePlanExecutorBlock` from the AgenticBlocks library supports execution in a Docker container — edit `make_executor_block` in `opalacoder/agents.py` changing `execution_mode="local"` to `execution_mode="docker"`.
+- Never run the agent in `auto` mode with access to production systems without reviewing the generated subplans.
+
+---
+
+## License
+
+MIT

opalacoder-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+opalacoder/__init__.py,sha256=8Bawhbei8CD1Y0IEU-BF73c6DZT-3Cxft5qNcaUPeog,106
+opalacoder/agents.py,sha256=F45PyJ0utG3zDoVp_vbdB79gMZCm1aYCWuGQDA5oP8g,10651
+opalacoder/api_keys.py,sha256=O8dXsKPLi-mUGNKkzX2ZuHmepi9Aj8TIROrkp3vN6e4,2526
+opalacoder/cli.py,sha256=wDYeuIwdU9JxanCko9dfjxFJBmgIDBu6FiSXkZJcsjE,13957
+opalacoder/cli_commands.py,sha256=ElOkySzZupYYk5M7VBaAuvhWQ-kSYcZvsbo1xAty0L4,11538
+opalacoder/config.py,sha256=8m8MyB0B3mkYTgEfYuYW7DCmrvu-pl1iBzpJ3kHIxQA,7318
+opalacoder/embeddings.py,sha256=6Z8reaUjFktkp6X80wH5k-vq3h2aBworC6dI-ocHieA,3031
+opalacoder/i18n.py,sha256=pMMd25jDnGW8WW75fzPwJFoTq2Xj87vVEjXnmq7e1mg,15453
+opalacoder/orchestrator.py,sha256=Vpb3AkB0ZmARSHx06RnIAWhhsdbGDmaRkf51CiPmePg,16325
+opalacoder/planner.py,sha256=K8_bdxrMsL_TA-NHW51Dq0AlrspKOamp5SHUQwj2NNc,7839
+opalacoder/project.py,sha256=TFw3cQsQbV7M9_YDy217k7bShnOTZov7yDSlAZ3UJyo,7912
+opalacoder/session.py,sha256=Lxr4vB6-EMeMt_ygk_m_Oaz8AbQneXzdINf-X8nXOrM,215
+opalacoder/skills.py,sha256=KjgpL8oYZKTM6RZCQWlicqzZ-NnzRPTYn8m2iSFTwHk,7740
+opalacoder/structured.py,sha256=DjJvuFoVpc3PJARSwuCgT92E7z19zTsPK_XJ0fuE9Vo,4252
+opalacoder/terminal.py,sha256=VQtBS1o_clS8nQ2rk372TLtTxUUIi-zjD0eNwwRNiCA,6846
+opalacoder/tools.py,sha256=DPaIcUXDi0j83GVyD4niUE25cHgh9HvdcxxODLw6v6Y,13241
+opalacoder/vcs.py,sha256=YhwYRYLqj1QfLJOagHGXRtcWc8RqbJQnhZMufgKH6Lg,9629
+opalacoder/agents.yaml,sha256=8-Bz0FR5ZHtVsWvrA3rK4qbSMStdGxCnsCcwaBsQV44,2086
+opalacoder/skills/generaldeveloper.md,sha256=nQovGfechp7VO2178F_mhFmB_HBBynjPiO3Tk1Ljhao,2895
+opalacoder/skills/html_css_js.md,sha256=_0ofClJ7Wzah44BJKrsIXzHJ1Se56gt9Jt-fhv-oXqc,2703
+opalacoder/skills/opalacoder.md,sha256=izpXE5RDkFYRwajVefoHM-tkPuk88l3_t-QBk_vsRhE,2257
+opalacoder/skills/python_subprocess.md,sha256=g19gZZkczfDjwUD2LFZqQVQXZYKRkE5fVt0y7z5tZ_s,698
+opalacoder/skills/react_vite.md,sha256=asVCnIBZ4HbIj2JLtKTAFaHSa2-44jvISXWjnl3u7WI,456
+opalacoder-0.1.0.dist-info/METADATA,sha256=n-OAqeg1AvREC1_cAJrOk_VBdCrByo2g-zn9e2LDH9o,8660
+opalacoder-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+opalacoder-0.1.0.dist-info/entry_points.txt,sha256=QRzRb2C0E2oetScVmSVhoXUJge_pN3kymfkKiWsxwYs,51
+opalacoder-0.1.0.dist-info/RECORD,,

opalacoder-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

opalacoder-0.1.0.dist-info/entry_points.txt

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