better-opencode-async-agents 0.1.1 → 0.2.1

package/CHANGELOG.md

@@ -11,6 +11,12 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 - **Tool call parameter preview**: Forked context now shows tool parameters (up to 200 chars) instead of just tool names
 
 ### Breaking Changes
+- **BREAKING** Renamed all tools from `superagents_*` to `asyncagents_*`:
+  - `superagents_task` → `asyncagents_task`
+  - `superagents_output` → `asyncagents_output`
+  - `superagents_cancel` → `asyncagents_cancel`
+  - `superagents_list` → `asyncagents_list`
+  - `superagents_clear` → `asyncagents_clear`
 - **BREAKING** Renamed all tools from `background_*` to `superagents_*`:
   - `background_task` → `superagents_task`
   - `background_output` → `superagents_output`

package/README.md

@@ -3,7 +3,12 @@
 [![npm version](https://img.shields.io/npm/v/better-opencode-async-agents)](https://www.npmjs.com/package/better-opencode-async-agents)
 [![license](https://img.shields.io/npm/l/better-opencode-async-agents)](https://github.com/mainsoft-2024/better-opencode-async-agents/blob/main/LICENSE)
 
-An unopinionated, **Non-Blocking(optional), Async** Background agent plugin for OpenCode, **same as (or better than) that of Claude Code!**
+An unopinionated, 
+**Async**, 
+Forkable, 
+Resumable, 
+Parallelizable
+multi-agent plugin for OpenCode.
 
 ## Configuration
 
@@ -15,24 +20,44 @@ Add the plugin to your `opencode.json(c)`:
 }
 ```
 
-## Features
+## Overview
 
-- **Async Task Execution**: Run long-running agent tasks in parallel without blocking
-- **Real-time Progress Tracking**: Live updates with spinner animations and tool call counts
-- **Toast Notifications**: Visual status updates directly in your OpenCode UI
-- **Automatic Completion Notifications**: Get notified when tasks finish (success/error/cancelled)
-- **Batch Task Management**: Track multiple tasks as a batch with progress indicators
-- **Result Retrieval**: Block or non-blocking result fetching with configurable timeouts
-- **Session Integration**: Tasks automatically clean up when parent sessions change or are deleted
+This is the subagent/subtask plugin we all know and love, with some key features that support advanced agent control:
+
+- **Async & Batch Task Execution**: Run multiple agent tasks in parallel without blocking the main conversation. Launch tasks individually or in batches and continue working while they execute.
+
+- **Real-time Progress Tracking**: Live updates with spinner animations and tool call counts. See exactly what each agent is doing as it works.
+
+- **Resumable & Cancellable**: Resume completed tasks with follow-up messages for multi-turn conversations. Cancel running tasks at any time.
+
+- **Context Forking Support**: Fork the current conversation context to spawn new agent sessions that inherit the parent's context.
+
+- **Automatic Context Truncation**: When forking, context is intelligently truncated to fit within token limits while preserving the most relevant information.
+
+- **Dynamic Agent Response Collection**: Collect responses from agents in blocking or non-blocking modes. Wait for all tasks to complete or check progress incrementally.
+
+- **Variable Timeouts**: Configure custom timeouts per task. Some tasks need seconds, others need minutes - you decide.
 
 ## Tools Provided
 
-- **`superagents_task(description: string, prompt: string, agent: string)`**: Launch async background agent tasks
-- **`superagents_output(task_id: string, block: boolean, timeout?: number)`**: Get task results (blocking/non-blocking)
-- **`superagents_cancel(task_id: string)`**: Cancel running tasks
-- **`superagents_resume(task_id: string, message: string, block?: boolean, timeout?: number)`**: Resume a completed task with a follow-up message for multi-turn conversations
-- **`superagents_list(status?: "running" | "completed" | "error" | "cancelled")`**: List all tasks with status filter
-- **`superagents_clear()`**: Abort and clear all tasks
+| Tool | Description |
+|------|-------------|
+| `asyncagents_task` | Launch async background agent tasks with description, prompt, and agent type |
+| `asyncagents_output` | Get task results (blocking or non-blocking) with configurable timeout |
+| `asyncagents_cancel` | Cancel a running task |
+| `asyncagents_list` | List all tasks with optional status filter |
+| `asyncagents_clear` | Abort and clear all tasks |
+
+## Philosophy
+
+This is an unopinionated tool. It provides the primitives for async multi-agent orchestration without imposing a specific workflow. You decide:
+
+- When to block vs. fire-and-forget
+- How to structure your agent hierarchy
+- What context to fork and when
+- How long to wait for results
+
+Build your own patterns on top of these building blocks.
 
 ## Development
 
@@ -46,14 +71,8 @@ bun run build
 # Run tests
 bun test
 
-# Run linter
-bun run lint
-
 # Type check
 bun run typecheck
-
-# Format code
-bun run format
 ```
 
 ## License
@@ -62,6 +81,4 @@ MIT
 
 ---
 
-## Support
-
-For issues, questions, or contributions, please visit the [GitHub repository](https://github.com/mainsoft-2024/better-opencode-async-agents).
+For issues, questions, or contributions, visit the [GitHub repository](https://github.com/mainsoft-2024/better-opencode-async-agents).

package/dist/index.js

@@ -635,8 +635,8 @@ Arguments:
 
 IMPORTANT: You'll be informed when each task is complete. DO NOT assume all tasks were done, check again if all agents you need are complete.
 
-Returns immediately with task ID. The task will run in background and notify you when complete.
-Optionally use \`superagents_output\` later if you need to check results manually with or without blocking.`,
+  Returns immediately with task ID. The task will run in background and notify you when complete.
+Optionally use \`asyncagents_output\` later if you need to check results manually with or without blocking.`,
   backgroundList: `List all background tasks.
 
 Shows all running, completed, error, and cancelled background tasks with their status.
@@ -696,10 +696,10 @@ ${textContent || "(No text response)"}`,
 };
 var ERROR_MESSAGES = {
   taskNotFound: (taskId) => `Task not found: ${taskId}`,
-  taskNotFoundWithHint: (taskId) => `Task not found: ${taskId}. Use superagents_list to see available tasks.`,
+  taskNotFoundWithHint: (taskId) => `Task not found: ${taskId}. Use asyncagents_list to see available tasks.`,
   taskCurrentlyResuming: "Task is currently being resumed. Wait for completion.",
   onlyCompletedCanResume: (currentStatus) => `Only completed tasks can be resumed. Current status: ${currentStatus}`,
-  sessionExpired: "Session expired or was deleted. Start a new superagents_task to continue.",
+  sessionExpired: "Session expired or was deleted. Start a new asyncagents_task to continue.",
   agentRequired: "Agent parameter is required. Specify which agent to use.",
   promptRequired: "Prompt is required when resuming a task",
   launchFailed: (message) => `Failed to launch background task: ${message}`,
@@ -732,14 +732,14 @@ var NOTIFICATION_MESSAGES = {
   devHintIndicator: "[hint attached]"
 };
 var SYSTEM_HINT_MESSAGES = {
-  runningTasksHint: (taskId) => `If you need results immediately, use superagents_output(task_id="${taskId}").
+  runningTasksHint: (taskId) => `If you need results immediately, use asyncagents_output(task_id="${taskId}").
 You can continue working or just say 'waiting' and halt.
 WATCH OUT for leftovers, you will likely WANT to wait for all agents to complete.`,
   allTasksDoneHint: (totalCount) => `All ${totalCount} tasks finished.
-Use superagents_output tools to see agent responses.`,
+Use asyncagents_output tools to see agent responses.`,
   errorHint: (taskId, errorMessage) => `Task failed: ${errorMessage}
-Use superagents_output(task_id="${taskId}") for details.`,
-  resumeHint: (taskId) => `Use superagents_output(task_id="${taskId}") for full response.`
+Use asyncagents_output(task_id="${taskId}") for details.`,
+  resumeHint: (taskId) => `Use asyncagents_output(task_id="${taskId}") for full response.`
 };
 var TOAST_TITLES = {
   taskCompleted: "✓ Task completed",
@@ -747,7 +747,7 @@ var TOAST_TITLES = {
   taskCancelled: "⊘ Task cancelled",
   backgroundTasksRunning: (spinner) => {
     const prefix = process.env.OPENCODE_BGAGENT_PREFIX;
-    const baseText = "Superagents";
+    const baseText = "AsyncAgents";
     return prefix ? `⛭ ${prefix} ${baseText}` : `⛭ ${baseText}`;
   },
   tasksComplete: "✓ Tasks complete"
@@ -1523,11 +1523,11 @@ ${contextText}`;
     body: {
       agent: input.agent,
       tools: {
-        superagents_task: false,
-        superagents_output: false,
-        superagents_cancel: false,
-        superagents_list: false,
-        superagents_clear: false
+        asyncagents_task: false,
+        asyncagents_output: false,
+        asyncagents_cancel: false,
+        asyncagents_list: false,
+        asyncagents_clear: false
       },
       parts: [{ type: "text", text: input.prompt }]
     }
@@ -14522,11 +14522,11 @@ async function plugin(ctx) {
   const manager = new BackgroundManager(ctx);
   return {
     tool: {
-      superagents_task: createBackgroundTask(manager),
-      superagents_output: createBackgroundOutput(manager),
-      superagents_cancel: createBackgroundCancel(manager),
-      superagents_list: createBackgroundList(manager),
-      superagents_clear: createBackgroundClear(manager)
+      asyncagents_task: createBackgroundTask(manager),
+      asyncagents_output: createBackgroundOutput(manager),
+      asyncagents_cancel: createBackgroundCancel(manager),
+      asyncagents_list: createBackgroundList(manager),
+      asyncagents_clear: createBackgroundClear(manager)
     },
     event: async () => {}
   };
@@ -14535,5 +14535,5 @@ export {
   plugin as default
 };
 
-//# debugId=B22DEAF300A4886E64756E2164756E21
+//# debugId=E81274522F3E3FAA64756E2164756E21
 //# sourceMappingURL=index.js.map