plutus-ai 0.3.2__tar.gz

plutus_ai-0.3.2/.claude/settings.json

@@ -0,0 +1,19 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(pytest tests*)",
+      "Bash(ruff check*)",
+      "Bash(pip install*)",
+      "Bash(cd ui && npm*)",
+      "Bash(git status*)",
+      "Bash(git diff*)",
+      "Bash(git log*)",
+      "Bash(git branch*)",
+      "Bash(git add*)",
+      "Bash(git commit*)",
+      "Bash(git push*)",
+      "Bash(plutus*)"
+    ],
+    "deny": []
+  }
+}

plutus_ai-0.3.2/.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+*.egg
+.eggs/
+*.whl
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Node.js / UI
+ui/node_modules/
+ui/.vite/
+
+# Plutus runtime
+.plutus/
+*.db
+audit.jsonl
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Testing
+.pytest_cache/
+htmlcov/
+.coverage

plutus_ai-0.3.2/ARCHITECTURE.md

@@ -0,0 +1,65 @@
+# Plutus Agent — Architecture
+
+## Core Enhancement: Subprocess-Spawning AI Agent
+
+The key upgrade is a **subprocess orchestrator** that allows Claude to:
+
+1. **Spawn worker subprocesses** — isolated child processes for file editing, code analysis, and tool creation
+2. **Parallel execution** — multiple workers can run simultaneously  
+3. **Dynamic tool creation** — Claude can write new tools at runtime and hot-load them
+4. **Sandboxed execution** — each subprocess runs in its own context with resource limits
+
+## Module Structure
+
+```
+plutus/
+├── __init__.py
+├── __main__.py
+├── cli.py                    # Enhanced CLI with interactive REPL mode
+├── config.py                 # Configuration management
+├── core/
+│   ├── agent.py              # Main agent runtime (enhanced)
+│   ├── conversation.py       # Conversation/context management
+│   ├── heartbeat.py          # Heartbeat system
+│   ├── llm.py                # LLM client (LiteLLM)
+│   ├── memory.py             # SQLite memory store
+│   ├── planner.py            # Plan management
+│   └── subprocess_manager.py # NEW: Subprocess orchestrator
+├── gateway/                  # Web API + WebSocket
+├── guardrails/               # Permission tiers + audit
+├── skills/                   # YAML skill definitions
+└── tools/
+    ├── base.py               # Tool base class
+    ├── registry.py           # Tool registry (enhanced with hot-reload)
+    ├── filesystem.py         # File operations
+    ├── shell.py              # Shell commands
+    ├── process.py            # Process management
+    ├── code_analysis.py      # NEW: AST-based code analysis
+    ├── code_editor.py        # NEW: Intelligent code editing
+    ├── tool_creator.py       # NEW: Dynamic tool creation
+    ├── subprocess_tool.py    # NEW: Subprocess spawning tool
+    ├── browser.py
+    ├── clipboard.py
+    ├── desktop.py
+    ├── system_info.py
+    └── app_manager.py
+```
+
+## Subprocess Architecture
+
+```
+Main Agent Process
+├── SubprocessManager
+│   ├── Worker Pool (configurable max)
+│   ├── Task Queue (priority-based)
+│   └── Result Collector
+├── Workers
+│   ├── FileEditWorker    — applies diffs, creates files
+│   ├── CodeAnalysisWorker — AST parsing, linting, dependency analysis
+│   ├── ShellWorker       — sandboxed command execution
+│   └── CustomWorker      — runs dynamically-created tools
+└── Communication
+    ├── stdin/stdout JSON protocol
+    ├── Shared temp directory for large payloads
+    └── Event stream back to agent
+```

plutus_ai-0.3.2/CLAUDE.md

@@ -0,0 +1,78 @@
+# Plutus - AI Agent with Full System Control
+
+## Quick Reference
+
+```bash
+# Install
+pip install -e ".[dev]"
+cd ui && npm install
+
+# Run
+plutus start            # Production (serves built UI)
+plutus start --dev      # Dev mode (Vite proxy on :5173)
+
+# Test
+pytest tests            # All tests
+pytest tests -x -q      # Stop on first failure, quiet output
+
+# Lint
+ruff check plutus/      # Check Python
+ruff check --fix plutus/ # Auto-fix
+
+# Build UI
+cd ui && npm run build  # TypeScript check + Vite build → ui/dist/
+```
+
+## Architecture
+
+Monorepo: Python backend (`plutus/`) + React/TypeScript frontend (`ui/`).
+
+### Backend (`plutus/`)
+
+- **`core/agent.py`** — Main agent loop. `process_message()` yields `AgentEvent` objects. Tool rounds are capped by `config.agent.max_tool_rounds` (plan tool calls don't count toward the limit).
+- **`core/llm.py`** — LLM client via LiteLLM. Model-agnostic (Anthropic, OpenAI, Ollama, custom).
+- **`core/memory.py`** — SQLite-backed async store (aiosqlite). Conversations, messages, learned facts.
+- **`core/conversation.py`** — Message history management with context windowing.
+- **`core/planner.py`** — Built-in plan tool for multi-step task tracking.
+- **`core/heartbeat.py`** — Autonomous background execution with configurable intervals.
+- **`gateway/server.py`** — FastAPI server, lifespan setup, static UI serving.
+- **`gateway/routes.py`** — REST API endpoints for config, guardrails, history, approvals.
+- **`gateway/ws.py`** — WebSocket handler for real-time agent events.
+- **`guardrails/`** — 4-tier permission system (observer → assistant → operator → autonomous). Policies in `tiers.py`, engine in `engine.py`, audit logging.
+- **`tools/`** — Tool implementations (shell, filesystem, browser, process, system_info, clipboard, desktop, app_manager). Each extends base `Tool` class with async `execute()`.
+- **`config.py`** — Pydantic config stored at `~/.plutus/config.json`. Secrets in `~/.plutus/.secrets.json` (chmod 600).
+
+### Frontend (`ui/`)
+
+- React 19 + TypeScript 5.6 + Vite 6 + TailwindCSS 3.4
+- Zustand for state (`stores/appStore.ts`)
+- Components: `chat/`, `dashboard/`, `settings/`, `guardrails/`
+- API client: `lib/api.ts` — REST calls to FastAPI backend
+- WebSocket hook: `hooks/useWebSocket.ts` — real-time event streaming
+
+### Key Patterns
+
+- **Event streaming**: Agent emits typed events (`thinking`, `text`, `tool_call`, `tool_result`, `done`) → WebSocket → UI renders in real time.
+- **Guardrail flow**: Every tool call → `guardrails.check()` → allowed / denied / requires_approval → approval queue with timeout.
+- **Config updates**: UI PATCH `/api/config` → `config.update(patch)` → deep merge → save to disk. Some settings (heartbeat) apply live via dedicated endpoints.
+
+## Code Style
+
+- Python: ruff with `line-length = 100`, rules `E, F, I, N, W, UP`, target `py311`
+- Use `from __future__ import annotations` in all Python files
+- Type hints everywhere (Pydantic models for config, typed dicts for tool results)
+- Async-first: all I/O operations use async/await
+- Frontend: TypeScript strict mode, functional React components with hooks
+
+## Testing
+
+- pytest with `asyncio_mode = "auto"` — async tests just work
+- Test files: `tests/test_config.py`, `tests/test_guardrails.py`, `tests/test_tools.py`
+- Run `pytest tests -x -q` before committing
+
+## Config Locations
+
+- `~/.plutus/config.json` — All settings (model, guardrails, gateway, memory, heartbeat, planner, agent)
+- `~/.plutus/.secrets.json` — API keys only (chmod 600, never in config.json)
+- `~/.plutus/memory.db` — SQLite conversation/memory store
+- `~/.plutus/skills/` — User-defined YAML skills

plutus_ai-0.3.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Plutus Contributors
+
+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.

plutus_ai-0.3.2/PKG-INFO

@@ -0,0 +1,438 @@
+Metadata-Version: 2.4
+Name: plutus-ai
+Version: 0.3.2
+Summary: Autonomous AI agent with subprocess orchestration, dynamic tool creation, and a local-first web interface
+Project-URL: Homepage, https://github.com/plutus-ai/plutus
+Project-URL: Repository, https://github.com/plutus-ai/plutus
+Project-URL: Issues, https://github.com/plutus-ai/plutus/issues
+Author: Plutus Contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,ai,autonomous,guardrails,local-first
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Dist: anthropic>=0.40.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: litellm>=1.55.0
+Requires-Dist: playwright>=1.49.0
+Requires-Dist: psutil>=6.1.0
+Requires-Dist: pyautogui>=0.9.54
+Requires-Dist: pydantic-settings>=2.6.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pyperclip>=1.8.0
+Requires-Dist: python-multipart>=0.0.18
+Requires-Dist: pywinauto>=0.6.8; sys_platform == 'win32'
+Requires-Dist: rich>=13.9.0
+Requires-Dist: uvicorn[standard]>=0.32.0
+Requires-Dist: websockets>=14.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Plutus — Autonomous AI Agent with Subprocess Orchestration
+
+<p align="center">
+  <strong>A better, easier-to-use AI agent that spawns subprocesses to edit code, analyze files, and create new tools on the fly.</strong>
+</p>
+
+<p align="center">
+  <a href="#features">Features</a> •
+  <a href="#quick-start">Quick Start</a> •
+  <a href="#architecture">Architecture</a> •
+  <a href="#tools">Tools</a> •
+  <a href="#dynamic-tool-creation">Dynamic Tools</a> •
+  <a href="#configuration">Configuration</a>
+</p>
+
+---
+
+## What is Plutus?
+
+Plutus is an autonomous AI agent system that gives Claude (or any LLM) the ability to **spawn isolated subprocesses** for file editing, code analysis, shell execution, and dynamic tool creation. Think of it as **Claude Code on steroids** — the AI can not only run commands and edit files, but also create entirely new tools at runtime to solve problems it wasn't originally designed for.
+
+### Key Differentiators
+
+| Feature | OpenClaw | Plutus |
+|---------|----------|--------|
+| File editing | Basic read/write | Subprocess-isolated surgical edits with diff output |
+| Code analysis | None | Full AST analysis (functions, classes, complexity, call graphs) |
+| Subprocess spawning | None | Parallel worker pool with JSON protocol |
+| Dynamic tool creation | None | Create, validate, and hot-load new Python tools at runtime |
+| CLI experience | Basic | Rich interactive REPL with slash commands |
+| Guardrails | Basic | 4-tier system (observer → autonomous) with audit logging |
+| Planning | None | Built-in plan/step tracking with auto-progress |
+
+## Features
+
+### Subprocess Orchestration
+The agent spawns isolated worker subprocesses for every operation — file edits, code analysis, shell commands, and custom scripts all run in their own process with resource limits and timeouts.
+
+### Intelligent Code Editing
+Surgical find/replace edits with diff output. The agent reads files, applies precise changes, and verifies the result — all in subprocess isolation.
+
+### Deep Code Analysis
+AST-based analysis of Python files:
+- Function and class extraction with signatures
+- Cyclomatic complexity scoring (A–F ratings)
+- Import dependency mapping
+- Call graph generation
+- TODO/FIXME/HACK detection
+- Module summarization
+
+### Dynamic Tool Creation
+The agent can write new Python tools at runtime:
+1. Writes the tool code
+2. Validates it (syntax check)
+3. Saves it to `~/.plutus/custom_tools/`
+4. Hot-loads it into the tool registry
+5. Uses it immediately
+
+### 4-Tier Guardrail System
+- **Observer** — Read-only, AI can only observe
+- **Assistant** — Every action requires user approval
+- **Operator** — Pre-approved actions run autonomously
+- **Autonomous** — Full control, no restrictions
+
+### Multiple Interfaces
+- **Terminal REPL** (`plutus chat`) — Rich interactive chat with slash commands
+- **Single prompt** (`plutus run "..."`) — Execute one task and exit
+- **Web UI** (`plutus start`) — Full web interface with WebSocket streaming
+
+## Quick Start
+
+### Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/Crypt0nly/plutus.git
+cd plutus
+
+# Install with pip
+pip install -e .
+
+# Run setup wizard
+plutus setup
+```
+
+### First Run
+
+```bash
+# Interactive terminal chat
+plutus chat
+
+# Or run a single prompt
+plutus run "Create a Python script that sorts a CSV file by the second column"
+
+# Or launch the web UI
+plutus start
+```
+
+### Chat Commands
+
+Inside `plutus chat`, use slash commands:
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show available commands |
+| `/tools` | List all available tools |
+| `/plan` | Show current execution plan |
+| `/clear` | Start a new conversation |
+| `/tier` | Show or change guardrail tier |
+| `/workers` | Show active subprocesses |
+| `/exit` | Exit the chat |
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                   Agent Runtime                      │
+│  ┌──────────┐  ┌──────────┐  ┌──────────────────┐  │
+│  │   LLM    │  │ Planner  │  │   Guardrails     │  │
+│  │ (Claude) │  │          │  │ (4-tier system)  │  │
+│  └────┬─────┘  └──────────┘  └──────────────────┘  │
+│       │                                              │
+│  ┌────▼──────────────────────────────────────────┐  │
+│  │              Tool Registry                     │  │
+│  │  ┌────────┐ ┌────────────┐ ┌───────────────┐  │  │
+│  │  │ Shell  │ │ Code Editor│ │ Code Analysis │  │  │
+│  │  └────────┘ └────────────┘ └───────────────┘  │  │
+│  │  ┌────────────┐ ┌──────────────┐ ┌─────────┐  │  │
+│  │  │ Subprocess │ │ Tool Creator │ │ Browser │  │  │
+│  │  └────────────┘ └──────────────┘ └─────────┘  │  │
+│  │  ┌──────────┐ ┌─────────┐ ┌─────────────────┐ │  │
+│  │  │Filesystem│ │ Process │ │ Custom Tools... │ │  │
+│  │  └──────────┘ └─────────┘ └─────────────────┘ │  │
+│  └───────────────────┬───────────────────────────┘  │
+│                      │                               │
+│  ┌───────────────────▼───────────────────────────┐  │
+│  │           Subprocess Manager                   │  │
+│  │  ┌─────────────┐  ┌──────────────────────┐    │  │
+│  │  │ Worker Pool │  │  JSON stdin/stdout    │    │  │
+│  │  │ (max: 8)    │  │  protocol             │    │  │
+│  │  └─────────────┘  └──────────────────────┘    │  │
+│  └───────────────────────────────────────────────┘  │
+│                      │                               │
+│  ┌───────────────────▼───────────────────────────┐  │
+│  │           Worker Subprocesses                  │  │
+│  │  ┌──────┐ ┌──────────┐ ┌──────────┐ ┌──────┐ │  │
+│  │  │Shell │ │File Edit │ │Code Anal.│ │Custom│ │  │
+│  │  │Worker│ │Worker    │ │Worker    │ │Worker│ │  │
+│  │  └──────┘ └──────────┘ └──────────┘ └──────┘ │  │
+│  └───────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────┘
+```
+
+### Subprocess Communication Protocol
+
+Workers communicate via **JSON over stdin/stdout** (one JSON object per line):
+
+```
+Agent → Worker:  {"action": "edit", "path": "/file.py", "edits": [...]}
+Worker → Agent:  {"success": true, "result": {"changes": 2, "diff": "..."}}
+```
+
+This design provides:
+- **Isolation** — each operation runs in its own process
+- **Safety** — crashes in workers don't affect the agent
+- **Parallelism** — multiple workers can run simultaneously
+- **Simplicity** — JSON protocol is easy to debug and extend
+
+## Tools
+
+### Built-in Tools
+
+| Tool | Description |
+|------|-------------|
+| `shell` | Execute shell commands |
+| `filesystem` | File system operations (legacy, still available) |
+| `code_editor` | Create, read, and edit files via subprocess |
+| `code_analysis` | AST-based Python code analysis via subprocess |
+| `subprocess` | Direct subprocess spawning for parallel tasks |
+| `tool_creator` | Create new tools at runtime |
+| `process` | System process management |
+| `system_info` | System information queries |
+| `browser` | Web browsing (Playwright) |
+| `clipboard` | Clipboard operations |
+| `desktop` | Desktop/window management |
+| `app_manager` | Application management |
+
+### Code Editor Operations
+
+```
+read       — Read file content (with optional line range)
+write      — Create or overwrite a file
+append     — Append content to a file
+edit       — Apply surgical find/replace edits
+delete     — Delete a file or directory
+move       — Move/rename a file
+copy       — Copy a file or directory
+mkdir      — Create directories
+list       — List directory contents
+find       — Find files by glob pattern
+grep       — Search file contents with regex
+diff       — Show diff between two files
+```
+
+### Code Analysis Operations
+
+```
+analyze        — Full analysis (everything below combined)
+find_functions — List all function/method definitions with signatures
+find_classes   — List all class definitions with methods
+find_imports   — Extract all import statements
+find_todos     — Find TODO/FIXME/HACK/NOTE comments
+complexity     — Calculate cyclomatic complexity per function
+symbols        — Extract all top-level symbols
+call_graph     — Build function call graph
+summarize      — Generate human-readable summary
+```
+
+## Dynamic Tool Creation
+
+The agent can create new tools when it encounters a task that requires capabilities it doesn't have:
+
+```python
+# Example: Agent creates a CSV processor tool
+tool_creator(
+    operation="create",
+    tool_name="csv_processor",
+    description="Process and transform CSV files",
+    code="""
+import csv
+from pathlib import Path
+
+def main(args):
+    path = args.get('path', '')
+    operation = args.get('operation', 'read')
+    
+    if operation == 'read':
+        with open(path) as f:
+            reader = csv.DictReader(f)
+            rows = list(reader)
+        return {'success': True, 'result': {'rows': rows, 'count': len(rows)}}
+    
+    elif operation == 'sort':
+        column = args.get('column', '')
+        with open(path) as f:
+            reader = csv.DictReader(f)
+            rows = sorted(list(reader), key=lambda r: r.get(column, ''))
+        return {'success': True, 'result': {'rows': rows, 'count': len(rows)}}
+    
+    return {'success': False, 'error': f'Unknown operation: {operation}'}
+"""
+)
+```
+
+Created tools are:
+- **Validated** — syntax-checked before saving
+- **Persisted** — saved to `~/.plutus/custom_tools/` across sessions
+- **Hot-loaded** — immediately available in the tool registry
+- **Isolated** — executed in subprocess workers
+
+## Configuration
+
+### Config File: `~/.plutus/config.json`
+
+```json
+{
+  "model": {
+    "provider": "anthropic",
+    "model": "claude-sonnet-4-6",
+    "temperature": 0.7,
+    "max_tokens": 4096
+  },
+  "guardrails": {
+    "tier": "operator",
+    "audit_enabled": true
+  },
+  "agent": {
+    "max_tool_rounds": 25
+  },
+  "planner": {
+    "enabled": true,
+    "auto_plan": true
+  },
+  "gateway": {
+    "host": "127.0.0.1",
+    "port": 7777
+  }
+}
+```
+
+### Supported Providers
+
+| Provider | Models | Config |
+|----------|--------|--------|
+| Anthropic | Claude 4 Sonnet, Claude 4 Opus, etc. | `ANTHROPIC_API_KEY` |
+| OpenAI | GPT-4.1, GPT-4.1-mini, etc. | `OPENAI_API_KEY` |
+| Ollama | Llama 3.2, Mistral, etc. | Local, no key needed |
+| Custom | Any OpenAI-compatible endpoint | `API_KEY` + base URL |
+
+### API Keys
+
+Keys are stored securely in `~/.plutus/.secrets.json` (chmod 600) and never exposed via the API. Set them via:
+
+```bash
+# Setup wizard
+plutus setup
+
+# Environment variable
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# Or via the web UI settings page
+```
+
+## CLI Reference
+
+```bash
+plutus                  # Show help
+plutus start            # Launch web UI + API server
+plutus chat             # Interactive terminal chat
+plutus run "prompt"     # Run a single prompt
+plutus setup            # Setup wizard
+plutus status           # Show configuration
+plutus tools            # List available tools
+plutus set-tier <tier>  # Change guardrail tier
+plutus audit            # Show audit log
+plutus config-show      # Display full config as JSON
+```
+
+## Development
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest tests/ -v
+
+# Run specific test file
+pytest tests/test_subprocess.py -v
+
+# Lint
+ruff check plutus/
+```
+
+## Project Structure
+
+```
+plutus/
+├── plutus/
+│   ├── __init__.py
+│   ├── __main__.py
+│   ├── cli.py                      # CLI with chat REPL
+│   ├── config.py                   # Configuration management
+│   ├── core/
+│   │   ├── agent.py                # Main agent runtime
+│   │   ├── conversation.py         # Conversation management
+│   │   ├── heartbeat.py            # Heartbeat system
+│   │   ├── llm.py                  # LLM client (LiteLLM)
+│   │   ├── memory.py               # SQLite memory store
+│   │   ├── planner.py              # Plan management
+│   │   └── subprocess_manager.py   # Subprocess orchestrator
+│   ├── gateway/                    # Web API + WebSocket
+│   ├── guardrails/                 # Permission tiers + audit
+│   ├── skills/                     # YAML skill definitions
+│   ├── tools/
+│   │   ├── base.py                 # Tool base class
+│   │   ├── registry.py             # Tool registry with hot-reload
+│   │   ├── code_analysis.py        # AST-based code analysis
+│   │   ├── code_editor.py          # File creation and editing
+│   │   ├── subprocess_tool.py      # Direct subprocess spawning
+│   │   ├── tool_creator.py         # Dynamic tool creation
+│   │   ├── shell.py                # Shell commands
+│   │   ├── filesystem.py           # File system operations
+│   │   ├── process.py              # Process management
+│   │   ├── browser.py              # Web browsing
+│   │   └── ...
+│   └── workers/
+│       ├── shell_worker.py         # Shell command worker
+│       ├── file_edit_worker.py     # File editing worker
+│       ├── code_analysis_worker.py # Code analysis worker
+│       └── custom_worker.py        # Dynamic tool worker
+├── ui/                             # React web interface
+├── tests/
+│   ├── test_subprocess.py          # 34 comprehensive tests
+│   ├── test_config.py
+│   ├── test_guardrails.py
+│   └── test_tools.py
+├── pyproject.toml
+└── README.md
+```
+
+## License
+
+MIT License — see [LICENSE](LICENSE) for details.