npm - adelie-ai - Versions diffs - 0.2.0 → 0.2.2 - Mend

adelie-ai 0.2.0 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md +302 -288
package/adelie/cli.py +334 -5
package/adelie/dashboard.py +8 -0
package/adelie/orchestrator.py +2 -2
package/adelie/project_context.py +22 -1
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -1,254 +1,312 @@
 <p align="center">
-  <img src="docs/adelie_logo.jpeg" alt="Adelie Logo" width="200" />
+  <img src="docs/adelie_logo.jpeg" alt="Adelie" width="180" />
 </p>
 <h1 align="center">Adelie</h1>
 <p align="center">
-  <strong>Self-Communicating Autonomous AI Loop System</strong><br/>
-  An AI orchestrator that plans, codes, reviews, tests, deploys, and evolves — autonomously.
+  <strong>Autonomous AI Orchestration System</strong><br/>
+  <sub>10 specialized agents · 6-phase lifecycle · zero human intervention</sub>
 </p>
 <p align="center">
-  <img src="https://img.shields.io/badge/python-3.10+-blue?style=for-the-badge&logo=python&logoColor=white" alt="Python 3.10+" />
-  <img src="https://img.shields.io/badge/LLM-Gemini%20%7C%20Ollama-orange?style=for-the-badge" alt="LLM Support" />
-  <img src="https://img.shields.io/badge/license-MIT-green?style=for-the-badge" alt="MIT License" />
-  <img src="https://img.shields.io/badge/tests-183%20passed-brightgreen?style=for-the-badge" alt="Tests" />
+  <a href="https://www.npmjs.com/package/adelie-ai"><img src="https://img.shields.io/npm/v/adelie-ai?style=flat-square&logo=npm&color=CB3837" alt="npm version" /></a>
+  <img src="https://img.shields.io/badge/python-3.10+-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python" />
+  <img src="https://img.shields.io/badge/LLM-Gemini%20│%20Ollama-FF6F00?style=flat-square" alt="LLM" />
+  <img src="https://img.shields.io/badge/tests-197%20passing-2EA043?style=flat-square" alt="Tests" />
+  <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue?style=flat-square" alt="License" /></a>
 </p>
 <p align="center">
-  <a href="#-quick-start">Quick Start</a> ·
-  <a href="#-architecture">Architecture</a> ·
-  <a href="#-features">Features</a> ·
-  <a href="#-cli-reference">CLI</a> ·
-  <a href="#-testing">Testing</a> ·
-  <a href="#-license">License</a>
+  <a href="#quick-start">Quick Start</a>&ensp;·&ensp;
+  <a href="#how-it-works">How It Works</a>&ensp;·&ensp;
+  <a href="#architecture">Architecture</a>&ensp;·&ensp;
+  <a href="#cli">CLI</a>&ensp;·&ensp;
+  <a href="#dashboard">Dashboard</a>&ensp;·&ensp;
+  <a href="#configuration">Configuration</a>
 </p>
 ---
-## 🤔 What is Adelie?
+## Overview
-Adelie is an **autonomous AI loop system** that orchestrates 10 specialized AI agents to build, maintain, and evolve software projects — with minimal human intervention.
-Think of it as a full AI development team running 24/7:
+Adelie is an autonomous AI orchestrator that plans, codes, reviews, tests, deploys, and evolves software projects through a coordinated multi-agent loop. It ships as a single CLI (`npm install -g adelie-ai`) and requires only an LLM provider — no cloud backend, no account.
 ```
- 🧠 Expert AI    →  Strategic decisions & task dispatch
- ✍️  Writer AI    →  Knowledge Base documentation
- 💻 Coder AI     →  Code generation (3-layer architecture)
- 🔍 Reviewer AI  →  Code quality review & feedback
- 🧪 Tester AI    →  Test execution & failure reporting
- 🚀 Runner AI    →  Build & deployment
- 📡 Monitor AI   →  System health monitoring
- 📊 Analyst AI   →  Project insights & analysis
- 🔎 Research AI  →  Web search for external info
- 🔬 Scanner AI   →  Codebase scanning on first run
+    (o_    Adelie v0.2.1
+    //\    ollama · deepseek-v3.1:671b-cloud
+    V_/_   Phase: mid_2
 ```
-All agents communicate through a **file-based Knowledge Base** and are coordinated by the **Orchestrator** — an endless loop with a built-in state machine.
+**What Adelie does in every cycle:**
----
+1. **Writer** curates the Knowledge Base
+2. **Expert** makes strategic decisions — what to build next, what to fix
+3. **Research** gathers external context from the web
+4. **Coder** generates code in 3 dependency layers
+5. **Reviewer** scores code quality; rejects until standards are met
+6. **Checkpoint** snapshots the project before promotion
+7. **Tester** runs tests and reports failures
+8. **Runner** builds, installs, deploys
+9. **Monitor** watches system health
+10. **Phase gates** decide when to advance the project lifecycle
-## ✨ Features
+The loop runs continuously at a configurable interval (default 30 s), or once with `adelie run once`.
-### 🎯 Core
+---
-- **10 Specialized Agents** — Each with a focused role, scheduled independently
-- **6-Phase Project Lifecycle** — `INITIAL → MID → MID_1 → MID_2 → LATE → EVOLVE`
-- **Layered Code Generation** — Layer 0 (features) → Layer 1 (connectors) → Layer 2 (infra)
-- **Knowledge Base** — Tag-based & semantic retrieval across 6 categories
-- **Multi-LLM** — Gemini + Ollama with automatic fallback chains
+## Quick Start
-### 🛡️ Safety
+### Prerequisites
-- **Loop Detector** — 5 stuck-pattern types with escalating interventions
-- **Phase Gates** — Quality-metric thresholds (KB count, test rate, review scores)
-- **Context Budget** — Per-agent token limits prevent unbounded growth
-- **Process Supervisor** — Timeout enforcement, orphan cleanup, concurrency limits
+| Requirement | Version |
+|:--|:--|
+| Python | 3.10+ |
+| Node.js | 16+ |
+| LLM | Gemini API key **or** Ollama instance |
-### 🔌 Extensibility (New in Phase 2-3)
+### Install
-| Feature | Description |
-|---------|-------------|
-| 💾 **Checkpoint System** | Auto-snapshot before file promotion, instant rollback |
-| 🐳 **Docker Sandboxing** | Configurable workspace access, network isolation, security blocklist |
-| 🌐 **REST Gateway** | HTTP API: `/api/status`, `/api/tools`, `/api/control` |
-| 🧩 **Skill Registry** | Install/update/uninstall skills from Git or local dirs |
-| 📡 **Multichannel** | `ChannelProvider` ABC — Discord, Slack, and custom channels |
-| 🤝 **A2A Protocol** | Agent-to-Agent HTTP API for external agent integration |
-| 🔧 **MCP Support** | Model Context Protocol for external tool ecosystems |
+#### npm (recommended)
----
+```bash
+npm install -g adelie-ai
+```
-## 🏗️ Architecture
+#### curl (macOS / Linux)
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                        ORCHESTRATOR                              │
-│                                                                  │
-│   ┌──────────┐    ┌──────────┐    ┌──────────────┐              │
-│   │ Writer AI│───>│Expert AI │───>│ Coder Manager│              │
-│   └──────────┘    └──────────┘    └──────┬───────┘              │
-│        │               │                 │                       │
-│        v               │          ┌──────┴──────┐               │
-│   ┌──────────┐         │          │  Layer 0-2  │               │
-│   │Knowledge │         │          │   Coders    │               │
-│   │   Base   │<────────┘          └──────┬──────┘               │
-│   └──────────┘                           │                       │
-│                                          v                       │
-│   ┌──────────┐  ┌──────────┐  ┌──────────────────┐             │
-│   │ Reviewer │  │ Tester   │  │ Runner / Monitor │             │
-│   │    AI    │  │    AI    │  │       AI         │             │
-│   └──────────┘  └──────────┘  └──────────────────┘             │
-│                                                                  │
-│   ┌─────────────────────────────────────────────────────────┐   │
-│   │ Loop Detector │ Scheduler │ Process Supervisor          │   │
-│   ├─────────────────────────────────────────────────────────┤   │
-│   │ Checkpoint    │ Sandbox   │ Gateway │ A2A │ Channels    │   │
-│   └─────────────────────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────────────────────┘
+```bash
+curl -fsSL https://raw.githubusercontent.com/Ade1ie/adelie/main/install.sh | bash
 ```
----
+#### PowerShell (Windows)
-## 🔄 Project Lifecycle
+```powershell
+irm https://raw.githubusercontent.com/Ade1ie/adelie/main/install.ps1 | iex
+```
-Adelie evolves your project through **6 phases**, each gated by quality metrics:
+#### Homebrew (macOS / Linux)
-```
-INITIAL ──> MID ──> MID_1 ──> MID_2 ──> LATE ──> EVOLVE
-Planning    Code    Test      Optimize  Maintain  Autonomous
+```bash
+brew tap Ade1ie/tap
+brew install adelie
 ```
-| Phase | Focus | Coder Layers |
-|-------|-------|-------------|
-| Initial | Documentation, architecture, roadmap | — |
-| Mid | Implementation, feature coding | Layer 0 |
-| Mid-1 | Integration, testing | Layer 0-1 |
-| Mid-2 | Stabilization, optimization | Layer 0-2 |
-| Late | Maintenance, new features | All |
-| Evolve | Self-improvement | All |
+#### From source
----
+```bash
+git clone https://github.com/Ade1ie/adelie.git
+cd adelie
+pip install -r requirements.txt
+python adelie/cli.py --version
+```
-## 🚀 Quick Start
+### Update
-### Prerequisites
-- **Python 3.10+**
-- **Node.js 16+** (for CLI wrapper)
-- **Gemini API key** or **Ollama** running locally
+```bash
+# npm
+npm install -g adelie-ai@latest
-### Installation
+# curl / PowerShell — re-run the install command above
-```bash
-# Install via npm (recommended)
-npm install -g adelie-ai
+# Homebrew
+brew upgrade adelie
-# Or install from source
-git clone https://github.com/kimhyunbin/Adelie.git
-cd Adelie
-pip install -r requirements.txt
-npm install -g .
+# Check current version
+adelie --version
 ```
-### Setup
+### Configure
 ```bash
-# Initialize workspace
-cd /path/to/your/project
+cd your-project/
 adelie init
-# Configure LLM provider
-adelie config --provider gemini --api-key YOUR_GEMINI_API_KEY
+# Gemini
+adelie config --provider gemini --api-key YOUR_KEY
-# Or use Ollama (local, free)
+# or Ollama (local, free)
 adelie config --provider ollama --model gemma3:12b
 ```
 ### Run
 ```bash
-# Start the autonomous AI loop
+# Continuous autonomous loop
 adelie run --goal "Build a REST API for task management"
 # Single cycle
 adelie run once --goal "Analyze and document the codebase"
 ```
+The real-time **dashboard** opens automatically at **http://localhost:5042**.
+---
+## How It Works
+### Agents
+| Agent | Role | When |
+|:--|:--|:--|
+| **Writer** | Curates Knowledge Base — skills, logic, dependencies, exports | Every cycle |
+| **Expert** | Strategic JSON decisions — action + coder tasks + phase vote | Every cycle |
+| **Scanner** | Scans existing codebase on first run | Once |
+| **Coder** | Multi-layer code generation with dependency ordering | On demand |
+| **Reviewer** | Quality review (1–10 score) with retry-on-reject | After coding |
+| **Tester** | Executes tests, collects failures, feeds back to coder | After review |
+| **Runner** | Installs deps, builds, deploys (whitelisted commands) | Mid-phase + |
+| **Monitor** | System health, resource checks, service restarts | Periodic |
+| **Analyst** | Trend analysis, insights, KB synthesis | Periodic |
+| **Research** | Web search → KB for external knowledge | On demand |
+### 6-Phase Lifecycle
+<p align="center">
+  <img src="docs/lifecycle.png" alt="Adelie 6-Phase Lifecycle" width="800" />
+</p>
+Each phase transition is gated by quality metrics — KB file count, test pass rate, review scores, stability indicators. The Expert AI votes on phase transitions; the system enforces the gates.
+### Layered Code Generation
+The Coder Manager dispatches tasks across three dependency layers:
+- **Layer 0** — Features and pages (parallel execution)
+- **Layer 1** — Connectors and integrations (depends on Layer 0)
+- **Layer 2** — Infrastructure and configuration (depends on Layer 1)
+Failed layers trigger targeted retries with reviewer feedback.
+---
+## Architecture
+<p align="center">
+  <img src="docs/architecture.png" alt="Adelie Architecture" width="800" />
+</p>
+---
+## Dashboard
+Adelie serves a real-time monitoring UI at **`http://localhost:5042`** (auto-starts with `adelie run`).
+- **Agent grid** — live status of all 10 agents (idle / running / done / error)
+- **Log stream** — real-time SSE-powered log feed with category filtering
+- **Cycle metrics** — tokens, LLM calls, files written, test results, review scores
+- **Phase timeline** — visual progress through the 6-phase lifecycle
+- **Cycle history chart** — last 30 cycles at a glance
+Built with zero external dependencies — Python `http.server` + SSE + embedded HTML/JS.
+| Setting | Default | Env var |
+|:--|:--|:--|
+| Enable | `true` | `DASHBOARD_ENABLED` |
+| Port | `5042` | `DASHBOARD_PORT` |
 ---
-## 💻 CLI Reference
+## CLI
+```bash
+adelie --version                  # Show version
+adelie help                       # Full command reference
 ```
-Workspace
-  adelie init [dir]              Initialize workspace
-  adelie ws                      List all workspaces
-  adelie ws remove <N>           Remove workspace #N
-Run
-  adelie run --goal "..."        Start AI loop
-  adelie run ws <N>              Resume loop in workspace #N
-  adelie run once --goal "..."   Run one cycle
-Configuration
-  adelie config                  Show current config
-  adelie config --provider ...   Switch LLM (gemini/ollama)
-  adelie config --model ...      Set model name
-  adelie config --interval N     Loop interval (seconds)
-  adelie config --api-key KEY    Set Gemini API key
-  adelie config --lang ko|en     Display language
-Monitoring
-  adelie status                  System health
-  adelie inform                  Project status report
-  adelie phase                   Show phase
-  adelie phase set <phase>       Set phase manually
-  adelie metrics                 Cycle metrics
-Knowledge Base
-  adelie kb                      KB file counts
-  adelie kb --clear-errors       Clear error files
-  adelie kb --reset              Reset KB (destructive)
-Project
-  adelie goal                    Show project goal
-  adelie goal set "..."          Set project goal
-  adelie feedback "message"      Send feedback to AI loop
-  adelie research "topic"        Web search → KB
-  adelie git                     Git status & recent commits
-Ollama
-  adelie ollama list             List models
-  adelie ollama pull <model>     Download model
-  adelie ollama run [model]      Interactive chat
-Telegram
-  adelie telegram setup          Setup bot token
-  adelie telegram start          Start Telegram bot
+### Workspace
+```bash
+adelie init [dir]                 # Initialize .adelie workspace
+adelie ws                         # List all workspaces
+adelie ws remove <N>              # Remove workspace
 ```
----
+### Execution
+```bash
+adelie run --goal "…"             # Start continuous loop
+adelie run once --goal "…"        # Single cycle
+adelie run ws <N>                 # Resume workspace #N
+```
+### Configuration
-## 🔧 Configuration
+```bash
+adelie config                     # Show current config
+adelie config --provider ollama   # Switch LLM provider
+adelie config --model gpt-4o     # Set model
+adelie config --api-key KEY       # Set Gemini API key
+adelie config --ollama-url URL    # Set Ollama server URL
+```
-### Environment Variables
+### Settings
+```bash
+adelie settings                   # View all settings
+adelie settings --global          # View global settings
+adelie settings set <key> <val>   # Change workspace setting
+adelie settings set --global <key> <val>  # Change global setting
+adelie settings reset <key>       # Reset to default
+```
-All settings stored in `.adelie/.env`:
+Available settings: `dashboard`, `dashboard.port`, `loop.interval`, `plan.mode`, `sandbox`, `mcp`, `browser.search`, `browser.max_pages`, `fallback.models`, `fallback.cooldown`, `language`
+### Monitoring
+```bash
+adelie status                     # System health & provider status
+adelie inform                     # AI-generated project report
+adelie phase                      # Show current phase
+adelie phase set <phase>          # Set phase manually
+adelie metrics                    # Cycle metrics & history
+```
+### Knowledge Base & Project
+```bash
+adelie kb                         # KB file counts by category
+adelie kb --clear-errors          # Clear error files
+adelie kb --reset                 # Reset entire KB
+adelie goal                       # Show project goal
+adelie goal set "…"               # Set project goal
+adelie feedback "message"         # Inject feedback into AI loop
+adelie research "topic"           # Web search → KB
+adelie spec load <file>           # Load spec (MD/PDF/DOCX) into KB
+adelie git                        # Git status & recent commits
+```
+### Integrations
+```bash
+adelie telegram setup             # Configure Telegram bot
+adelie telegram start             # Start Telegram bot
+adelie ollama list                # List Ollama models
+adelie ollama pull <model>        # Download model
+adelie ollama run [model]         # Interactive chat
+```
+---
+## Configuration
+### Environment (`.adelie/.env`)
 | Variable | Default | Description |
-|----------|---------|-------------|
+|:--|:--|:--|
 | `LLM_PROVIDER` | `gemini` | `gemini` or `ollama` |
-| `GEMINI_API_KEY` | — | Required for Gemini |
-| `GEMINI_MODEL` | `gemini-2.0-flash` | Gemini model |
-| `OLLAMA_BASE_URL` | `http://localhost:11434` | Ollama URL |
-| `OLLAMA_MODEL` | `llama3.2` | Ollama model |
-| `FALLBACK_MODELS` | — | Fallback chain (e.g. `gemini:flash,ollama:llama3.2`) |
-| `LOOP_INTERVAL_SECONDS` | `30` | Loop interval |
-| `ADELIE_LANGUAGE` | `ko` | Display language |
-### Docker Sandbox Config
+| `GEMINI_API_KEY` | — | Google Gemini API key |
+| `GEMINI_MODEL` | `gemini-2.0-flash` | Gemini model name |
+| `OLLAMA_BASE_URL` | `http://localhost:11434` | Ollama server URL |
+| `OLLAMA_MODEL` | `llama3.2` | Ollama model name |
+| `FALLBACK_MODELS` | — | Fallback chain (`gemini:flash,ollama:llama3.2`) |
+| `LOOP_INTERVAL_SECONDS` | `30` | Cycle interval in seconds |
+| `DASHBOARD_ENABLED` | `true` | Dashboard on/off |
+| `DASHBOARD_PORT` | `5042` | Dashboard port |
+| `PLAN_MODE` | `false` | Require approval before execution |
+| `SANDBOX_MODE` | `none` | `none`, `seatbelt`, or `docker` |
+### Docker Sandbox
 Optional `.adelie/sandbox.json`:
@@ -259,15 +317,14 @@ Optional `.adelie/sandbox.json`:
     "workspaceAccess": "rw",
     "network": "none",
     "memoryLimit": "512m",
-    "cpuLimit": 1.0,
-    "readOnlyRoot": false
+    "cpuLimit": 1.0
   }
 }
 ```
-### Skills
+### Custom Skills
-Place skills in `.adelie/skills/<name>/SKILL.md`:
+Place custom skills in `.adelie/skills/<name>/SKILL.md`:
 ```yaml
 ---
@@ -276,138 +333,95 @@ description: React/TypeScript best practices
 agents: [coder, reviewer]
 trigger: auto
 ---
-# Instructions
-Use functional components...
+Use functional components with TypeScript props…
 ```
 ---
-## 🧪 Testing
+## Platform Features
-```bash
-# Run all tests
-python -m pytest tests/ -v
-# Specific modules
-python -m pytest tests/test_checkpoint.py -v
-python -m pytest tests/test_gateway.py -v
-python -m pytest tests/test_a2a.py -v
-```
-**183 tests** across 8 test suites:
-| Suite | Tests | Coverage |
-|-------|-------|----------|
-| MCP Client | 35 | MCP server connection, tool discovery |
-| Tool Registry | 20 | Tool registration, categories, user tools |
-| Checkpoint | 16 | Create, restore, prune, metadata |
-| Docker Sandbox | 26 | Config, bind safety, Docker wrapping |
-| Gateway API | 18 | REST endpoints, auth, CORS |
-| Skill Registry | 19 | Install, uninstall, manifest, helpers |
-| Multichannel | 24 | Providers, router, broadcast, events |
-| A2A Protocol | 25 | Task lifecycle, persistence, HTTP API |
+| Feature | Description |
+|:--|:--|
+| 💾 **Checkpoints** | Auto-snapshot before promotion, instant rollback |
+| 🐳 **Docker Sandbox** | Configurable workspace isolation, network policy, resource limits |
+| 🌐 **REST Gateway** | HTTP API — `/api/status`, `/api/tools`, `/api/control` |
+| 🧩 **Skill Registry** | Install/update skills from Git repos or local directories |
+| 📡 **Multichannel** | `ChannelProvider` ABC — Discord, Slack, custom channels |
+| 🤝 **A2A Protocol** | Agent-to-Agent HTTP for external agent integration |
+| 🔧 **MCP Support** | Model Context Protocol for external tool ecosystems |
+| 📊 **Dashboard** | Real-time web UI with SSE streaming on port 5042 |
+| 🔄 **Loop Detector** | 5 stuck-pattern types with escalating interventions |
+| ⚡ **Scheduler** | Per-agent frequency control with cooldown/priority |
 ---
-## 📁 Project Structure
+## Testing
-```
-Adelie/
-├── adelie/                     # Core package
-│   ├── orchestrator.py         # Main loop controller (state machine)
-│   ├── cli.py                  # CLI commands
-│   ├── config.py               # Configuration & env loading
-│   ├── llm_client.py           # LLM abstraction (Gemini + Ollama)
-│   ├── checkpoint.py           # 💾 Checkpoint system
-│   ├── sandbox.py              # 🐳 Docker/Seatbelt sandboxing
-│   ├── gateway.py              # 🌐 REST API gateway
-│   ├── skill_manager.py        # 🧩 Skill loading & registry
-│   ├── scheduler.py            # Per-agent scheduling
-│   ├── phases.py               # Project lifecycle phases
-│   ├── hooks.py                # Event-driven plugin system
-│   ├── loop_detector.py        # Stuck-loop detection
-│   ├── context_engine.py       # Per-agent context assembly
-│   ├── process_supervisor.py   # Subprocess management
-│   ├── feedback_queue.py       # User feedback injection
-│   ├── channels/               # 📡 Multichannel abstraction
-│   │   ├── base.py             #   ChannelProvider ABC
-│   │   ├── discord.py          #   Discord integration
-│   │   ├── slack.py            #   Slack integration
-│   │   └── router.py           #   Multi-channel routing
-│   ├── a2a/                    # 🤝 Agent-to-Agent protocol
-│   │   ├── types.py            #   Task/Event types
-│   │   ├── server.py           #   A2A HTTP server
-│   │   └── persistence.py      #   Task persistence
-│   ├── agents/                 # AI agents (10 specialized)
-│   │   ├── expert_ai.py
-│   │   ├── writer_ai.py
-│   │   ├── coder_ai.py
-│   │   ├── reviewer_ai.py
-│   │   ├── tester_ai.py
-│   │   ├── runner_ai.py
-│   │   ├── monitor_ai.py
-│   │   ├── analyst_ai.py
-│   │   ├── research_ai.py
-│   │   └── scanner_ai.py
-│   └── kb/                     # Knowledge Base
-│       ├── retriever.py
-│       └── embedding_store.py
-├── tests/                      # 183 tests
-├── bin/                        # Node.js CLI wrapper
-├── requirements.txt            # Python dependencies
-└── package.json                # npm config
+```bash
+python -m pytest tests/ -v    # 197 tests
 ```
 ---
-## ⚙️ How It Works
+## Project Structure
-Each orchestrator cycle runs these steps:
-1. **Writer AI** creates/updates Knowledge Base files
-2. **Expert AI** reads KB and makes structured decisions (JSON)
-3. **Research AI** searches the web if requested
-4. **Coder Manager** dispatches code generation by layer
-5. **Reviewer AI** reviews code; retries on failure
-6. **💾 Checkpoint** snapshots current files before promotion
-7. **Staging → Project** promotes approved code
-8. **Tester AI** runs tests; retries on failure
-9. **Runner AI** builds and deploys
-10. **Monitor AI** checks health; restarts if needed
-11. **Phase Gates** evaluate readiness for next phase
-The loop runs continuously with the **Scheduler** controlling agent frequency and the **Loop Detector** intervening when the system gets stuck.
----
-## 🗺️ Roadmap
-- [x] **Phase 1** — MCP Server Integration
-- [x] **Phase 2** — Checkpoint System, Docker Sandboxing, REST Gateway
-- [x] **Phase 3** — Skill Registry, Multichannel, A2A Protocol
-- [ ] **Phase 4** — VS Code Extension, Web Dashboard, Plugin Marketplace
+```
+adelie/
+├── orchestrator.py          # Main loop — state machine + phase gates
+├── cli.py                   # All CLI commands
+├── config.py                # Configuration & env loading
+├── llm_client.py            # LLM abstraction (Gemini + Ollama + fallback)
+├── interactive.py           # REPL + dashboard integration
+├── dashboard.py             # Real-time web server (HTTP + SSE)
+├── dashboard_html.py        # Embedded dashboard UI template
+├── agents/                  # 10 specialized AI agents
+│   ├── writer_ai.py         #   Knowledge Base curator
+│   ├── expert_ai.py         #   Strategic decision maker
+│   ├── coder_ai.py          #   Code generator
+│   ├── coder_manager.py     #   Layer dispatch & retry
+│   ├── reviewer_ai.py       #   Quality reviewer
+│   ├── tester_ai.py         #   Test runner
+│   ├── runner_ai.py         #   Build & deploy
+│   ├── monitor_ai.py        #   Health monitor
+│   ├── analyst_ai.py        #   Trend analyzer
+│   ├── research_ai.py       #   Web researcher
+│   └── scanner_ai.py        #   Initial codebase scanner
+├── kb/                      # Knowledge Base (retriever + embeddings)
+├── channels/                # Multichannel providers (Discord, Slack)
+├── a2a/                     # Agent-to-Agent protocol
+├── checkpoint.py            # Snapshot & rollback
+├── sandbox.py               # Docker/Seatbelt isolation
+├── gateway.py               # REST API gateway
+├── skill_manager.py         # Skill registry
+├── loop_detector.py         # Stuck-pattern detection
+├── scheduler.py             # Per-agent scheduling
+├── phases.py                # Lifecycle phase definitions
+├── hooks.py                 # Event-driven plugin system
+├── process_supervisor.py    # Subprocess management
+└── env_strategy.py          # Runtime environment detection
+```
 ---
-## 🤝 Contributing
+## Contributing
-Contributions are welcome! Please feel free to submit Pull Requests.
+```bash
+git clone https://github.com/Ade1ie/adelie.git
+cd adelie
+pip install -r requirements.txt
+python -m pytest tests/ -v   # Ensure all tests pass
+```
-1. Fork the repository
-2. Create your feature branch (`git checkout -b feature/amazing-feature`)
-3. Run tests (`python -m pytest tests/ -v`)
-4. Commit your changes (`git commit -m 'Add amazing feature'`)
-5. Push to the branch (`git push origin feature/amazing-feature`)
-6. Open a Pull Request
+1. Fork → branch → implement → test → PR
+2. Follow existing code style and patterns
+3. Add tests for new features
 ---
-## 📄 License
-MIT — see [LICENSE](./LICENSE) for details.
+## License
----
+[MIT](./LICENSE)
 <p align="center">
-  <sub>Built with 🐧 Adelie — the penguin that codes</sub>
+  <sub>Built with 🐧 by the Adelie team</sub>
 </p>

package/adelie/cli.py CHANGED Viewed

@@ -11,6 +11,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import platform
 import shutil
 import subprocess
 import sys
@@ -290,6 +291,296 @@ def _sync_specs() -> None:
         console.print(f"[green]  > Auto-synced specs: {', '.join(parts)}[/green]")
+# ═══════════════════════════════════════════════════════════════════════════════
+# OS DETECTION
+# ═══════════════════════════════════════════════════════════════════════════════
+def _detect_os() -> dict:
+    """Detect the current OS, shell, and architecture."""
+    system = platform.system()   # "Windows", "Linux", "Darwin"
+    release = platform.release()
+    machine = platform.machine()  # "x86_64", "arm64", "AMD64"
+    version = platform.version()
+    # Detect shell
+    if system == "Windows":
+        shell = "PowerShell"
+        comspec = os.environ.get("COMSPEC", "")
+        # Detect if running in PowerShell vs cmd
+        if os.environ.get("PSModulePath"):
+            shell = "PowerShell"
+        elif "cmd.exe" in comspec.lower():
+            shell = "cmd"
+    else:
+        shell_path = os.environ.get("SHELL", "/bin/sh")
+        shell = Path(shell_path).name  # "bash", "zsh", "fish", etc.
+    # Friendly OS name
+    if system == "Darwin":
+        os_name = "macOS"
+        try:
+            mac_ver = platform.mac_ver()[0]
+            if mac_ver:
+                release = mac_ver
+        except Exception:
+            pass
+    elif system == "Windows":
+        os_name = "Windows"
+    else:
+        os_name = "Linux"
+        # Try to get distro info
+        try:
+            import distro  # type: ignore
+            os_name = f"Linux ({distro.name(pretty=True)})"
+        except ImportError:
+            # Fallback: read /etc/os-release
+            try:
+                osrel = Path("/etc/os-release").read_text()
+                for line in osrel.splitlines():
+                    if line.startswith("PRETTY_NAME="):
+                        os_name = f"Linux ({line.split('=', 1)[1].strip('\"')})"
+                        break
+            except Exception:
+                pass
+    return {
+        "system": system,
+        "os_name": os_name,
+        "release": release,
+        "machine": machine,
+        "version": version,
+        "shell": shell,
+    }
+def _generate_os_context(os_info: dict) -> str:
+    """Generate English OS-specific context markdown for AI agent prompts."""
+    system = os_info["system"]
+    os_name = os_info["os_name"]
+    release = os_info["release"]
+    machine = os_info["machine"]
+    shell = os_info["shell"]
+    header = (
+        f"## System Environment\n\n"
+        f"- **OS**: {os_name} {release} / {machine}\n"
+        f"- **Shell**: {shell}\n"
+    )
+    if system == "Windows":
+        return header + (
+            "- **Path separator**: `\\` (backslash)\n"
+            "- **Line ending**: CRLF\n\n"
+            "### Command Reference (use ONLY these for this OS)\n\n"
+            "| Task | Command |\n"
+            "|------|---------|\n"
+            "| Delete file | `Remove-Item -Force <path>` |\n"
+            "| Delete directory | `Remove-Item -Recurse -Force <path>` |\n"
+            "| Copy file | `Copy-Item <src> <dst>` |\n"
+            "| Move file | `Move-Item <src> <dst>` |\n"
+            "| List files | `Get-ChildItem` or `ls` |\n"
+            '| Set env variable | `$env:VAR = "value"` |\n'
+            "| Chain commands | `cmd1; cmd2` (PowerShell) |\n"
+            "| Run script | `.\\script.ps1` |\n"
+            "| Null device | `$null` or `NUL` |\n\n"
+            "### Docker on Windows\n"
+            '- Use PowerShell-style volume mounts: `-v "${PWD}:/app"`\n'
+            "- Container shell: use `/bin/sh` (NOT `/bin/bash` unless confirmed)\n"
+            "- Line endings: ensure Dockerfiles use LF, not CRLF\n"
+            "- Docker Desktop required (or WSL2 backend)\n\n"
+            "### Testing & Build\n"
+            "- Use `npx` or `npm run` for Node.js scripts\n"
+            "- Python: `python` (not `python3`)\n"
+            "- pytest: `python -m pytest`\n"
+            "- Avoid `&&` for chaining — use `;` in PowerShell\n"
+        )
+    elif system == "Darwin":
+        silicon_note = ""
+        if machine == "arm64":
+            silicon_note = (
+                "- On Apple Silicon (arm64): be aware of `--platform linux/amd64` for x86 images\n"
+                "- Homebrew packages are at `/opt/homebrew/`\n"
+            )
+        else:
+            silicon_note = "- Homebrew packages are at `/usr/local/`\n"
+        return header + (
+            "- **Path separator**: `/` (forward slash)\n"
+            "- **Line ending**: LF\n\n"
+            "### Command Reference (use ONLY these for this OS)\n\n"
+            "| Task | Command |\n"
+            "|------|---------|\n"
+            "| Delete file | `rm -f <path>` |\n"
+            "| Delete directory | `rm -rf <path>` |\n"
+            "| Copy file | `cp <src> <dst>` |\n"
+            "| Move file | `mv <src> <dst>` |\n"
+            "| List files | `ls -la` |\n"
+            '| Set env variable | `export VAR="value"` |\n'
+            "| Chain commands | `cmd1 && cmd2` |\n"
+            "| Run script | `bash script.sh` or `./script.sh` |\n"
+            "| Null device | `/dev/null` |\n\n"
+            "### Docker on macOS\n"
+            '- Volume mounts: `-v "$(pwd):/app"`\n'
+            "- Container shell: `/bin/bash` or `/bin/sh`\n"
+            "- Docker Desktop for Mac required\n"
+            f"{silicon_note}\n"
+            "### Testing & Build\n"
+            "- Python: `python3` (not `python`)\n"
+            "- pytest: `python3 -m pytest`\n"
+            "- Use `&&` for command chaining\n"
+        )
+    else:  # Linux
+        return header + (
+            "- **Path separator**: `/` (forward slash)\n"
+            "- **Line ending**: LF\n\n"
+            "### Command Reference (use ONLY these for this OS)\n\n"
+            "| Task | Command |\n"
+            "|------|---------|\n"
+            "| Delete file | `rm -f <path>` |\n"
+            "| Delete directory | `rm -rf <path>` |\n"
+            "| Copy file | `cp <src> <dst>` |\n"
+            "| Move file | `mv <src> <dst>` |\n"
+            "| List files | `ls -la` |\n"
+            '| Set env variable | `export VAR="value"` |\n'
+            "| Chain commands | `cmd1 && cmd2` |\n"
+            "| Run script | `bash script.sh` or `./script.sh` |\n"
+            "| Null device | `/dev/null` |\n\n"
+            "### Docker on Linux\n"
+            '- Volume mounts: `-v "$(pwd):/app"`\n'
+            "- Container shell: `/bin/bash` or `/bin/sh`\n"
+            "- May need `sudo` for Docker commands (unless user is in docker group)\n"
+            "- Native Docker Engine — no Docker Desktop needed\n\n"
+            "### Testing & Build\n"
+            "- Python: `python3` (not `python` on most distros)\n"
+            "- pytest: `python3 -m pytest`\n"
+            "- Use `&&` for command chaining\n"
+        )
+# ═══════════════════════════════════════════════════════════════════════════════
+# AUTO GOAL GENERATION
+# ═══════════════════════════════════════════════════════════════════════════════
+def _auto_generate_goal() -> str | None:
+    """
+    Auto-generate project Main Goal from spec files + project structure.
+    Uses LLM to analyze .adelie/specs/ and file tree, producing a comprehensive
+    project_goal.md that all agents reference.
+    Returns the generated goal summary, or None if no specs found.
+    """
+    import adelie.config as cfg
+    from adelie.kb import retriever
+    ws_root = _find_workspace_root()
+    specs_dir = ws_root / "specs"
+    goal_path = cfg.WORKSPACE_PATH / "logic" / "project_goal.md"
+    # If goal already exists, just return its summary
+    if goal_path.exists():
+        content = goal_path.read_text(encoding="utf-8")
+        # Extract first meaningful line as summary
+        for line in content.splitlines():
+            line = line.strip()
+            if line and not line.startswith("#") and not line.startswith("**") and not line.startswith("<!--"):
+                return line[:200]
+        return "Project goal defined (see project_goal.md)"
+    # Collect spec contents
+    spec_contents = ""
+    if specs_dir.exists():
+        for f in sorted(specs_dir.iterdir()):
+            if f.is_file() and not f.name.startswith(".") and f.suffix in (".md", ".txt", ".pdf", ".docx"):
+                try:
+                    text = f.read_text(encoding="utf-8")
+                    spec_contents += f"\n### {f.name}\n{text[:3000]}\n"
+                except Exception:
+                    pass
+    if not spec_contents.strip():
+        # No specs — no auto goal
+        return None
+    # Collect project structure
+    from adelie.project_context import get_tree_summary
+    file_tree = get_tree_summary()
+    # Also check KB for any scanner output
+    kb_summary = ""
+    try:
+        retriever.ensure_workspace()
+        kb_summary = retriever.get_index_summary()
+    except Exception:
+        pass
+    # LLM call to generate Main Goal
+    prompt = f"""You are analyzing a software project to create a comprehensive project roadmap.
+Your output will be used as the "Main Goal" document that guides ALL AI agents working on this project.
+## Spec Files (provided by user)
+{spec_contents}
+## Project Structure
+{file_tree}
+{f"## Existing Knowledge Base{chr(10)}{kb_summary}" if kb_summary else ""}
+Based on the above, create a structured project roadmap in markdown.
+The document should include:
+1. **Vision** — One paragraph summary of what this project aims to achieve
+2. **Objectives** — Numbered list of major objectives with measurable criteria
+3. **Technical Requirements** — Technologies, frameworks, architecture decisions
+4. **Milestones** — Phased delivery plan
+5. **Constraints & Notes** — Any important constraints or considerations
+Be thorough and specific — this document guides ALL AI agents.
+Output ONLY the markdown content, no extra commentary."""
+    console.print("[bold cyan]🎯 Auto-generating Main Goal from spec files...[/bold cyan]")
+    try:
+        from adelie.llm_client import generate
+        result = generate(
+            system_prompt="You are a project planning expert. Analyze the given specs and project structure to create a clear, actionable project roadmap.",
+            user_prompt=prompt,
+            temperature=0.3,
+        )
+        # Save to project_goal.md
+        goal_path.parent.mkdir(parents=True, exist_ok=True)
+        from datetime import datetime
+        header = (
+            f"<!-- auto-generated from specs at {datetime.now().isoformat(timespec='seconds')} -->\n"
+            f"<!-- regenerate with: adelie goal reset -->\n\n"
+        )
+        goal_path.write_text(header + result, encoding="utf-8")
+        # Update KB index
+        retriever.update_index(
+            "logic/project_goal.md",
+            tags=["goal", "project", "roadmap", "priority"],
+            summary="Auto-generated project Main Goal from spec files",
+        )
+        console.print("[green]  ✓ Main Goal generated → project_goal.md[/green]")
+        # Extract summary for display
+        first_line = ""
+        for line in result.splitlines():
+            line = line.strip()
+            if line and not line.startswith("#"):
+                first_line = line[:120]
+                break
+        return first_line or "Project goal auto-generated from specs"
+    except Exception as e:
+        console.print(f"[yellow]⚠️  Auto goal generation failed: {e}[/yellow]")
+        console.print("[dim]   Continuing without Main Goal — set manually with: adelie goal set \"...\"[/dim]")
+        return None
 # ═══════════════════════════════════════════════════════════════════════════════
 # INIT
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -335,6 +626,13 @@ def cmd_init(args: argparse.Namespace) -> None:
     specs_dir = adelie_dir / "specs"
     specs_dir.mkdir(parents=True, exist_ok=True)
+    # ── Detect OS ─────────────────────────────────────────────────────
+    os_info = _detect_os()
+    console.print(
+        f"[green]  +[/green] OS detected: [bold]{os_info['os_name']} {os_info['release']}[/bold] "
+        f"({os_info['machine']}, {os_info['shell']})"
+    )
     # ── Create config ────────────────────────────────────────────────────
     default_config = {
         "loop_interval": 30,
@@ -356,10 +654,33 @@ def cmd_init(args: argparse.Namespace) -> None:
             "detected_at": datetime.now().isoformat(timespec="seconds"),
         }
+    # Save OS info to config
+    default_config["os"] = {
+        "system": os_info["system"],
+        "os_name": os_info["os_name"],
+        "release": os_info["release"],
+        "machine": os_info["machine"],
+        "shell": os_info["shell"],
+        "detected_at": datetime.now().isoformat(timespec="seconds"),
+    }
     config_path = adelie_dir / "config.json"
     if not config_path.exists() or args.force:
         config_path.write_text(json.dumps(default_config, indent=2, ensure_ascii=False), encoding="utf-8")
+    # ── Generate context.md with OS info ──────────────────────────────
+    context_file = adelie_dir / "context.md"
+    os_context = _generate_os_context(os_info)
+    if not context_file.exists() or args.force:
+        context_file.write_text(os_context, encoding="utf-8")
+        console.print(f"[green]  +[/green] Generated context.md (OS-specific prompts)")
+    else:
+        # Append/update OS section if context.md already exists
+        existing = context_file.read_text(encoding="utf-8")
+        if "## System Environment" not in existing:
+            context_file.write_text(existing.rstrip() + "\n\n" + os_context, encoding="utf-8")
+            console.print(f"[green]  +[/green] Updated context.md with OS info")
     # ── Create .env template ─────────────────────────────────────────
     env_file = adelie_dir / ".env"
     if not env_file.exists() or args.force:
@@ -376,7 +697,7 @@ OLLAMA_BASE_URL=http://localhost:11434
 OLLAMA_MODEL=llama3.2
 # ── Ollama Cloud (ollama.com 클라우드 사용 시) ────────────────────────
-# OLLAMA_BASE_URL=https://api.ollama.com
+# OLLAMA_BASE_URL=https://ollama.com
 # OLLAMA_API_KEY=your-ollama-cloud-api-key
 # ── Fallback Chain ───────────────────────────────────────────────────
@@ -557,24 +878,32 @@ def cmd_run(args: argparse.Namespace) -> None:
         # Use last goal if no new goal specified
         goal = args.goal
-        if goal == "Operate and improve the Adelie autonomous AI system" and ws.get("last_goal"):
+        if not goal and ws.get("last_goal"):
             goal = ws["last_goal"]
         console.print(f"[bold cyan]{t('run.resuming', n=args.workspace_num)}[/bold cyan]")
         console.print(f"   [dim]{ws_path}[/dim]")
-        registry.update_last_used(ws_path, goal)
+        registry.update_last_used(ws_path, goal or "")
     else:
         goal = args.goal
         ws_root = _find_workspace_root()
         if ws_root.exists():
-            registry.update_last_used(str(ws_root.parent), goal)
+            registry.update_last_used(str(ws_root.parent), goal or "")
     _validate_provider()
     # Auto-sync spec files from .adelie/specs/
     _sync_specs()
+    # Auto-generate Main Goal if no --goal provided
+    if not goal:
+        goal_summary = _auto_generate_goal()
+        if goal_summary:
+            goal = goal_summary
+        else:
+            goal = "Autonomously develop and improve the project based on available context"
     # Get current phase from workspace config
     ws_config = _load_workspace_config()
     phase = ws_config.get("phase", "initial")
@@ -1750,7 +2079,7 @@ def main() -> None:
     p_run.add_argument("workspace_num", nargs="?", type=int, default=None,
                        help="Workspace number (use with 'ws')")
     p_run.add_argument("--goal", type=str,
-                       default="Operate and improve the Adelie autonomous AI system",
+                       default=None,
                        help="High-level goal for the AI agents")
     p_run.add_argument("--once", action="store_true",
                        help="Run exactly one cycle then exit")

package/adelie/dashboard.py CHANGED Viewed

@@ -286,6 +286,14 @@ class ThreadingDashboardHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
     daemon_threads = True
     allow_reuse_address = True
+    def handle_error(self, request, client_address):
+        """Silently ignore client-side disconnects (common on Windows)."""
+        import sys
+        exc = sys.exc_info()[1]
+        if isinstance(exc, (ConnectionAbortedError, ConnectionResetError, BrokenPipeError)):
+            return  # client closed connection early — nothing to do
+        super().handle_error(request, client_address)
 # ── Dashboard Server ─────────────────────────────────────────────────────────

package/adelie/orchestrator.py CHANGED Viewed

@@ -57,8 +57,8 @@ class Orchestrator:
     MAX_RECOVER_RETRIES = 3
     MAX_NEW_LOGIC_CYCLES = 3  # Force transition after N cycles in new_logic
-    def __init__(self, goal: str = "Operate the Adelie autonomous AI system", phase: str = "initial"):
-        self.goal = goal
+    def __init__(self, goal: str | None = None, phase: str = "initial"):
+        self.goal = goal or "Autonomously develop and improve the project"
         self.phase = phase
         self.state = LoopState.NORMAL
         self.loop_iteration = 0

package/adelie/project_context.py CHANGED Viewed

@@ -13,6 +13,7 @@ Provides:
 from __future__ import annotations
 import os
+import platform
 from datetime import datetime
 from pathlib import Path
 from typing import NamedTuple
@@ -135,7 +136,8 @@ def get_tree_summary() -> str:
     header = (
         f"📁 Project: {PROJECT_ROOT.name} | "
         f"{len(files)} files ({code_count} code, {config_count} config) | "
-        f"{_format_size(total_size)} total\n"
+        f"{_format_size(total_size)} total | "
+        f"{get_os_info()}\n"
     )
     truncated = ""
@@ -194,3 +196,22 @@ def _format_size(size: int) -> str:
         return f"{size / 1024:.1f}KB"
     else:
         return f"{size / (1024 * 1024):.1f}MB"
+def get_os_info() -> str:
+    """Return a one-line OS summary string for context injection."""
+    system = platform.system()
+    machine = platform.machine()
+    if system == "Darwin":
+        os_name = "macOS"
+        try:
+            ver = platform.mac_ver()[0]
+            if ver:
+                os_name = f"macOS {ver}"
+        except Exception:
+            pass
+    elif system == "Windows":
+        os_name = f"Windows {platform.release()}"
+    else:
+        os_name = f"Linux {platform.release()}"
+    return f"OS: {os_name} / {machine}"

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "adelie-ai",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Adelie — Self-Communicating Autonomous AI Loop CLI",
   "bin": {
     "adelie": "bin/adelie.js"