opencode-orchestrator 0.1.53 → 0.1.55

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 (5) hide show
  1. package/README.md +71 -141
  2. package/bin/orchestrator-linux-arm64 +0 -0
  3. package/bin/orchestrator-linux-x64 +0 -0
  4. package/dist/index.js +1 -1
  5. package/package.json +1 -1
package/README.md CHANGED
@@ -2,78 +2,23 @@
2
2
  <img src="assets/logo.png" alt="Logo" width="200" />
3
3
  </div>
4
4
 
5
- # OpenCode Orchestrator Plugin
5
+ # OpenCode Orchestrator
6
6
 
7
7
  > **Multi-Agent Plugin for [OpenCode](https://opencode.ai)**
8
8
 
9
9
  [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
10
10
  [![npm](https://img.shields.io/npm/v/opencode-orchestrator.svg)](https://www.npmjs.com/package/opencode-orchestrator)
11
- [![npm downloads](https://img.shields.io/npm/dt/opencode-orchestrator.svg)](https://www.npmjs.com/package/opencode-orchestrator)
12
- [![OpenCode Plugin](https://img.shields.io/badge/OpenCode-Plugin-purple.svg)](https://opencode.ai)
13
-
14
- **OpenCode Orchestrator** is a collaborative framework that enables **low-benchmark models to deliver senior-level engineering results**.
15
-
16
- By maximizing the **method of agent collaboration**, we overcome the inherent limitations of individual AI models. We don't just "chat" with AI; we use a structured engineering layer to ensure complex missions are executed with 100% reliability and relentlessly pushed to completion, regardless of the model's price point.
17
-
18
- **Core Philosophy: Excellence through Collaboration**
19
-
20
- We believe that **a perfect collaboration method is superior to individual intelligence**.
21
-
22
- * **Systems Engineering Fusion**: We integrate Operating System principles (Scheduling), Distributed Systems (Actor Model), and Algorithm Theory (Divide & Conquer) to transform unpredictable LLMs into a **controlled computing resource**.
23
- * **Relentless PDCA Loop**: Every change follows a strict **Plan-Do-Check-Act** cycle. This systematic approach ensures that high-level professional tasks are completed without the quality decay or hallucinations typical of raw LLM outputs.
24
- * **Architecture over Benchmarks**: By decomposing missions into atomic, verifiable tasks, we extract **high-fidelity outcomes** from cost-effective models, proving that superior architecture can outperform raw scale.
25
11
 
26
12
  ---
27
13
 
28
- ## Why Orchestrator?
14
+ ## What is this?
29
15
 
30
- | Traditional | With Orchestrator |
31
- |-------------|-------------------|
32
- | Expensive "Smart" Model required | **Affordable Model + Smart Process** |
33
- | High Token Costs (Huge Context) | **Token Efficient** (Filtered Context) |
34
- | Linear, Slow Execution | **Parallel, Fast Execution** |
35
- | Errors compound silently | **Self-Correcting Verification Loops** |
36
- | "Hope it works" | **Strategic Micro-Tasking** |
16
+ A 6-agent collaborative system that turns **affordable LLMs into reliable engineering teams**.
37
17
 
38
- ---
39
-
40
- - **🧩 Strategic Organization** — Maximizing output through intelligent role distribution
41
- - **📉 Token Economy** — Filtering noise to reduce costs and increase focus
42
- - **⚡ Parallel DAG** — Concurrent execution for speed and efficiency
43
- - **🔍 Micro-Tasking** — Atomic decomposition to prevent hallucinations
44
- - **🛡️ Style Guardian** — Strict AST-based linting and consistency checks
45
- - **🔄 Self-Healing** — Autonomous pivot strategies for complex errors
46
- - **🏗️ Rust Core** — Native performance for heavy lifting
47
-
48
- ---
49
-
50
- ## How It Works (Parallel DAG)
51
-
52
- Instead of a linear sequence, we use a **Directed Acyclic Graph (DAG)** to model your mission.
53
-
54
- ```
55
- Mission Start (/task)
56
- │
57
- ▼
58
- ┌───────────────┐
59
- │ PLANNER │ (Architect)
60
- └───────┬───────┘
61
- │
62
- ┌───────┴───────┐
63
- │ │ (Parallel Streams)
64
- ▼ ▼
65
- ┌───────────┐ ┌───────────┐
66
- │ Tasks (A) │ │ Tasks (B) │
67
- └─────┬─────┘ └─────┬─────┘
68
- │ │
69
- └───────┬───────┘
70
- ▼
71
- ┌───────────────┐
72
- │ REVIEWER │ (Style Guardian)
73
- └───────┬───────┘
74
- ▼
75
- ✅ MISSION COMPLETE
76
- ```
18
+ - **Atomic Decomposition** — Tasks broken into verifiable micro-units
19
+ - **PDCA Loop** — Plan → Do → Check → Act (self-correcting)
20
+ - **Parallel DAG** — Independent tasks run concurrently
21
+ - **Style Guardian** — Reviewer catches all errors before merge
77
22
 
78
23
  ---
79
24
 
@@ -83,31 +28,22 @@ Instead of a linear sequence, we use a **Directed Acyclic Graph (DAG)** to model
83
28
  npm install -g opencode-orchestrator
84
29
  ```
85
30
 
86
- > **Note**: After installation, **restart OpenCode** or run `opencode` in your terminal.
87
- > The plugin will automatically register itself in `~/.config/opencode/opencode.json` with its absolute path.
88
-
89
- ### Troubleshooting
90
- If the command `/task` does not appear:
91
- 1. Uninstall: `npm uninstall -g opencode-orchestrator`
92
- 2. Clear config: `rm -rf ~/.config/opencode` (Warning: resets all plugins)
93
- 3. Reinstall: `npm install -g opencode-orchestrator`
94
-
31
+ Restart OpenCode after installation.
95
32
 
96
33
  ---
97
34
 
98
- **The only command you need:**
35
+ ## Usage
99
36
 
100
37
  ```bash
101
38
  /task "Implement user authentication with JWT"
102
39
  ```
103
40
 
104
41
  The Orchestrator will:
105
- 1. **Decompose** the mission into a JSON Task DAG
106
- 2. **Parallel Execute** independent streams
107
- 3. **Search** proactively for patterns
108
- 4. **Code** with atomic precision
109
- 5. **Verify** via the Style Guardian (MANDATORY)
110
- 6. **Self-Heal** if errors occur
42
+ 1. **Plan** — Decompose into atomic tasks
43
+ 2. **Search** — Find patterns and context
44
+ 3. **Code** — Implement with precision
45
+ 4. **Review** — Verify via quality gate
46
+ 5. **Fix** — Self-heal if errors occur
111
47
 
112
48
  ---
113
49
 
@@ -115,85 +51,79 @@ The Orchestrator will:
115
51
 
116
52
  | Agent | Role |
117
53
  |-------|------|
118
- | **Orchestrator** | Team leader — coordinates, decides, adapts |
119
- | **Planner** | Breaks work into atomic tasks |
120
- | **Coder** | Implements one task at a time |
121
- | **Reviewer** | Quality gate — catches all errors |
122
- | **Fixer** | Targeted error resolution |
123
- | **Searcher** | Finds context before coding |
54
+ | Orchestrator | Team leader — coordinates the mission |
55
+ | Planner | Decomposes work into atomic tasks |
56
+ | Coder | Implements one task at a time |
57
+ | Reviewer | Quality gate — catches all errors |
58
+ | Fixer | Targeted error resolution |
59
+ | Searcher | Finds context before coding |
124
60
 
125
61
  ---
126
62
 
127
- - **[System Architecture (Deep Dive)](docs/ARCHITECTURE.md)**: Explore the Distributed Cognitive Architecture (DCA), PDCA Loop, and Actor Model internals.
128
- - **[Configuration](docs/CONFIGURATION.md)**: `opencode.toml` setup guide.
129
-
130
- ---
131
-
132
- ## Open Source
133
-
134
- MIT License. No telemetry. No backdoors.
135
-
136
- [github.com/agnusdei1207/opencode-orchestrator](https://github.com/agnusdei1207/opencode-orchestrator)
63
+ ## How It Works
137
64
 
138
- ---
139
-
140
- ## License
141
-
142
- MIT License. NO WARRANTY.
143
-
144
- [MIT](LICENSE)
65
+ ```
66
+ /task "mission"
67
+ │
68
+ ▼
69
+ ┌─────────────┐
70
+ │ PLANNER │
71
+ └──────┬──────┘
72
+ │
73
+ ┌──────┴──────┐
74
+ ▼ ▼
75
+ [Task A] [Task B] (parallel)
76
+ │ │
77
+ └──────┬──────┘
78
+ ▼
79
+ ┌─────────────┐
80
+ │ REVIEWER │
81
+ └──────┬──────┘
82
+ ▼
83
+ ✅ DONE
84
+ ```
145
85
 
146
86
  ---
147
87
 
148
- ## 🏛️ The Architecture: The PDCA & Distributed Cognitive Loop
149
-
150
- We have moved beyond simple "chatbots". **OpenCode Orchestrator** implements a **Deterministic Engineering Layer** built on top of the stochastic nature of LLMs,
151
- - **Strict PDCA Loop**: Guarantees quality via Plan-Do-Check-Act cycle.
152
- - **🔍 Micro-tasking**: Atomic decomposition to prevent hallucinations.
153
- - **🛡️ Style Guardian**: Strict AST-based linting and consistency checks by the Reviewer.
154
- - **🔄 Self-healing**: Autonomous pivoting strategies for complex errors.
155
- - **Distributed Cognitive System**: Intelligence layer acting like an OS Kernel.
156
- - **File-Based State**: Uses physical filesystem as RAM, ignoring context limits.
157
- We treat agents as **Semantic Compute Units**. By applying rigorous Computer Science principles, we achieve a level of reliability that no single model can match.
158
-
159
- ### 🧬 The "Grand Fusion" of Methodologies
160
- We explicitly fused three massive domains into one seamless workflow:
161
-
162
- 1. **PDCA Methodology (Quality Assurance)**:
163
- * **Plan (Planner)**: Recursively decomposes mission into atomic tasks ($O(log n)$).
164
- * **Do (Coder)**: Executes the atomic tasks in parallel (Distributed Actions).
165
- * **Check (Reviewer)**: Acts as a **Byzantine Fault Tolerance** node, strictly validating code against requirements.
166
- * **Act (Orchestrator)**: Merges successful states or **Pivots** (Dynamic Programming) if failures occur.
88
+ ## PDCA Control Loop
167
89
 
168
- 2. **Distributed Systems Theory (Actor Model)**:
169
- * Each agent operates as an independent **Actor** with isolated state.
170
- * **Context Sharding**: We treat context windows like RAM, paging data in/out via `temp_context` files to simulate **Infinite Context**.
171
-
172
- 3. **Algorithmic Efficiency**:
173
- * **Divide & Conquer**: Breaking complex problems into trivial $O(1)$ sub-problems.
174
- * **Dynamic Programming**: Storing intermediate results (State) to avoid redundant computation and allow for intelligent backtracking.
175
-
176
- ### 🚀 The Command: `/task`
90
+ ```
91
+ ┌─────────────────────────────────────────────────────┐
92
+ │ PDCA LOOP │
93
+ │ │
94
+ │ PLAN ──→ DO ──→ CHECK ──→ ACT │
95
+ │ │ │ │ │ │
96
+ │ Planner Coder Reviewer Orchestrator │
97
+ │ ↓ ↓ ↓ ↓ │
98
+ │ DAG Code Pass/Fail Merge/Pivot │
99
+ │ │ │
100
+ │ ┌───────┴───────┐ │
101
+ │ ↓ ↓ │
102
+ │ ✅ Pass ❌ Fail → Fixer │
103
+ └─────────────────────────────────────────────────────┘
104
+ ```
177
105
 
178
- The interface to this system is a single, powerful command:
106
+ ## Troubleshooting
179
107
 
108
+ If `/task` doesn't appear:
180
109
  ```bash
181
- /task "Refactor the authentication middleware and implement JWT rotation"
110
+ npm uninstall -g opencode-orchestrator
111
+ npm install -g opencode-orchestrator
182
112
  ```
183
113
 
184
- This triggers the **Distributed Task Loop**. It's not just a chat; it's a mission commitment.
114
+ ---
185
115
 
186
- ### The 5-Phase Efficiency Workflow
116
+ ## Docs
187
117
 
188
- 1. **🧠 Phase 1: Filtered Analysis**: The **Searcher** reads docs but filters out noise. We only feed the "critical path" to the Planner.
189
- 2. **🌲 Phase 2: Strategic Planning**: The **Planner** creates a JSON DAG. This is our roadmap. No token is wasted on aimless wandering.
190
- 3. **🚀 Phase 3: Parallel Execution**: The **Orchestrator** identifies independent tasks and runs them concurrently.
191
- 4. **🛡️ Phase 4: Sync & Verify**: The **Reviewer** acts as the gatekeeper. It checks syntax, logic, and *cross-file consistency*.
192
- 5. **💰 Phase 5: Cost-Effective Completion**: We achieve "Senior Developer" results at "Junior Intern" prices.
118
+ - [Architecture](docs/ARCHITECTURE.md)
119
+ - [Plugin Troubleshooting](docs/PLUGIN_TROUBLESHOOTING.md)
193
120
 
194
121
  ---
195
122
 
196
- ## ⚡ Fast-Paced Development
123
+ ## License
124
+
125
+ MIT License. [LICENSE](LICENSE)
126
+
127
+ ---
197
128
 
198
- This project is evolving **extremely fast**. We iterate rapidly to bring relentless execution to your workflow.
199
- Updates are frequent. Keep your version fresh.
129
+ **Fast-Paced Development** — Updates are frequent. Keep your version fresh.
package/bin/orchestrator-linux-arm64 CHANGED
Binary file
package/bin/orchestrator-linux-x64 CHANGED
Binary file
package/dist/index.js CHANGED
@@ -684,7 +684,7 @@ var OrchestratorPlugin = async (input) => {
684
684
  };
685
685
  }
686
686
  const orchestratorAgents = {
687
- orchestrator: {
687
+ Orchestrator: {
688
688
  name: "Orchestrator",
689
689
  description: "Mission Commander - 6-agent collaborative AI for complex tasks",
690
690
  systemPrompt: AGENTS.orchestrator.systemPrompt
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "opencode-orchestrator",
3
3
  "displayName": "OpenCode Orchestrator",
4
4
  "description": "Distributed Cognitive Architecture for OpenCode. Turns simple prompts into specialized multi-agent workflows (Planner, Coder, Reviewer).",
5
- "version": "0.1.53",
5
+ "version": "0.1.55",
6
6
  "author": "agnusdei1207",
7
7
  "license": "MIT",
8
8
  "repository": {