@hung319/opencode-hive 1.3.1 → 1.3.2

package/dist/mcp/ast-grep.d.ts

@@ -1,2 +1,9 @@
-import type { LocalMcpConfig } from './types';
+import type { RemoteMcpConfig, LocalMcpConfig } from './types';
+/**
+ * Ast-grep MCP for code analysis
+ *
+ * Prefers remote MCP when available, falls back to local npx
+ * Remote is preferred to avoid local installation
+ */
+export declare const astGrepRemoteMcp: RemoteMcpConfig;
 export declare const astGrepMcp: LocalMcpConfig;

package/dist/mcp/index.d.ts

@@ -1,2 +1,4 @@
 import type { McpConfig } from './types';
+import { astGrepMcp } from './ast-grep';
 export declare const createBuiltinMcps: (disabledMcps?: string[]) => Record<string, McpConfig>;
+export { astGrepMcp as astGrepLocalMcp };

package/dist/mcp/websearch.d.ts

@@ -1,2 +1,3 @@
-import type { RemoteMcpConfig } from './types';
+import type { RemoteMcpConfig, LocalMcpConfig } from './types';
 export declare const websearchMcp: RemoteMcpConfig;
+export declare const websearchLocalMcp: LocalMcpConfig;

package/dist/skills/registry.generated.d.ts

@@ -7,7 +7,7 @@ import type { SkillDefinition } from './types.js';
 /**
  * List of builtin skill names.
  */
-export declare const BUILTIN_SKILL_NAMES: readonly ["agents-md-mastery", "brainstorming", "code-reviewer", "dispatching-parallel-agents", "docker-mastery", "executing-plans", "parallel-exploration", "systematic-debugging", "test-driven-development", "verification-before-completion", "writing-plans"];
+export declare const BUILTIN_SKILL_NAMES: readonly ["agents-md-mastery", "ask-questions-if-underspecified", "brainstorming", "code-reviewer", "dispatching-parallel-agents", "docker-mastery", "executing-plans", "parallel-exploration", "systematic-debugging", "test-driven-development", "verification-before-completion", "writing-plans"];
 /**
  * All builtin skill definitions.
  */

package/dist/tools/artifact-search.d.ts

@@ -0,0 +1,23 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+/**
+ * artifact_search tool
+ *
+ * Requires: SQLite artifact-index database
+ *
+ * This tool searches through indexed artifacts (code snippets, documents, etc.)
+ * stored in a SQLite database. Before using, you need to:
+ *
+ * 1. Install the artifact-index: npm install -g artifact-index
+ * 2. Initialize the index: artifact-index init
+ * 3. Index your artifacts: artifact-index add <path>
+ *
+ * If the dependency is not available, this tool returns an error message
+ * explaining how to set it up.
+ */
+export interface ArtifactSearchArgs {
+    query: string;
+    limit?: number;
+    type?: "code" | "doc" | "all";
+}
+export declare function searchArtifacts(args: ArtifactSearchArgs): Promise<string>;
+export declare const artifactSearchTool: ToolDefinition;

package/dist/tools/btca-ask.d.ts

@@ -0,0 +1,24 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+/**
+ * btca_ask tool
+ *
+ * Requires: btca CLI (Bluetooth Classic Audio)
+ *
+ * This tool allows interaction with Bluetooth Classic Audio devices.
+ * It can send commands to paired Bluetooth devices, query device status,
+ * and control audio playback.
+ *
+ * Before using, you need to:
+ * 1. Install btca CLI: npm install -g btca-cli
+ * 2. Pair your Bluetooth device
+ * 3. Connect to the device: btca connect <device-name>
+ *
+ * If the dependency is not available, this tool returns an error message.
+ */
+export interface BtcaAskArgs {
+    command: "status" | "play" | "pause" | "next" | "prev" | "volume" | "list" | "connect" | "disconnect";
+    device?: string;
+    value?: string;
+}
+export declare function btcaAsk(args: BtcaAskArgs): Promise<string>;
+export declare const btcaAskTool: ToolDefinition;

package/dist/tools/gitingest.d.ts

@@ -0,0 +1,9 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+export interface GitingestArgs {
+    url: string;
+    maxFileSize?: number;
+    pattern?: string;
+    patternType?: "include" | "exclude";
+}
+export declare function fetchGitingest(args: GitingestArgs): Promise<string>;
+export declare const gitingestTool: ToolDefinition;

package/dist/tools/look-at.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Look At Tool
+ *
+ * Extract key information from a file to save context tokens.
+ * For large files, returns structure/outline instead of full content.
+ */
+import { type ToolDefinition } from "@opencode-ai/plugin";
+export interface LookAtArgs {
+    filePath: string;
+    extract?: "structure" | "imports" | "exports" | "all";
+}
+export declare const lookAtTool: ToolDefinition;

package/dist/tools/pty.d.ts

@@ -0,0 +1,45 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+/**
+ * PTY (Pseudo-Terminal) tools
+ *
+ * Requires: bun-pty package
+ *
+ * These tools provide interactive PTY management for running background processes,
+ * sending interactive input, and reading output on demand.
+ *
+ * Use cases:
+ * - Running dev servers (npm run dev, cargo watch)
+ * - Watch modes (npm test -- --watch)
+ * - Interactive programs (REPLs, prompts)
+ * - Long-running processes
+ *
+ * Before using, you need to:
+ * 1. Install opencode-pty plugin OR
+ * 2. Install bun-pty: npm install -g bun-pty
+ *
+ * Note: These tools provide a wrapper around the opencode-pty functionality.
+ * For full PTY support, consider using the opencode-pty plugin directly.
+ */
+export interface PtyStartArgs {
+    command: string;
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface PtySendArgs {
+    id: string;
+    input: string;
+}
+export interface PtyReadArgs {
+    id: string;
+    clear?: boolean;
+}
+export interface PtyKillArgs {
+    id: string;
+}
+export interface PtyListArgs {
+}
+export declare const ptyStartTool: ToolDefinition;
+export declare const ptySendTool: ToolDefinition;
+export declare const ptyReadTool: ToolDefinition;
+export declare const ptyKillTool: ToolDefinition;
+export declare const ptyListTool: ToolDefinition;

package/dist/utils/context-compression.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Context Compression Utility
+ *
+ * Provides automatic context compression for Hive when context reaches threshold.
+ * Similar to DCP (Dynamic Context Pruning) or oh-my-openagent's context management.
+ *
+ * Features:
+ * - Automatic compression at 50% context threshold
+ * - Trimming unnecessary tool outputs
+ * - Deduplication, write superseding, and error purging strategies
+ * - Zero-cost automatic pruning strategies
+ */
+interface MessageContent {
+    type: "text";
+    text?: string;
+}
+interface ToolCall {
+    id?: string;
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+interface Message {
+    role: "user" | "assistant" | "tool" | "system";
+    content?: string | MessageContent[];
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+export interface CompressionConfig {
+    /** Context threshold to trigger compression (0-1, default: 0.5 = 50%) */
+    threshold?: number;
+    /** Enable automatic compression */
+    enabled?: boolean;
+    /** Protected tool output patterns (glob) */
+    protectedTools?: string[];
+    /** Protect user messages from compression */
+    protectUserMessages?: boolean;
+    /** Maximum tool calls to keep after compression */
+    maxToolCalls?: number;
+}
+/**
+ * Estimate token count from messages (rough approximation)
+ * ~4 characters per token on average
+ */
+export declare function estimateTokens(messages: Message[]): number;
+/**
+ * Calculate context usage ratio (0-1)
+ */
+export declare function getContextUsage(messages: Message[], contextLimit: number): number;
+/**
+ * Check if context compression is needed
+ */
+export declare function needsCompression(messages: Message[], contextLimit: number, config?: CompressionConfig): boolean;
+/**
+ * Main compression function
+ * Applies all strategies to reduce context size
+ */
+export declare function compressContext(messages: Message[], config?: CompressionConfig, contextLimit?: number): {
+    compressed: Message[];
+    stats: CompressionStats;
+};
+export interface CompressionStats {
+    originalTokens: number;
+    compressedTokens: number;
+    reductionRatio: number;
+    originalMessages: number;
+    compressedMessages: number;
+}
+/**
+ * Build a compression hint prompt
+ * This is injected into context to guide the LLM
+ */
+export declare function buildCompressionHint(): string;
+/**
+ * Create a session compaction hook for Hive
+ * This can be used with experimental.session.compacting hook
+ */
+export declare function createCompactionHook(config?: CompressionConfig): (input: {
+    sessionID: string;
+    messages?: Message[];
+    contextLimit?: number;
+}, output: {
+    context: string[];
+    prompt?: string;
+}) => void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hung319/opencode-hive",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",

package/skills/ask-questions-if-underspecified/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: ask-questions-if-underspecified
+description: Clarify requirements before implementing. Use when serious doubts arise.
+use_when: >
+  When a request has multiple plausible interpretations or key details
+  (objective, scope, constraints, environment, or safety) are unclear,
+  load this skill before starting implementation.
+  Do NOT use when the request is already clear or when a quick, low-risk
+  discovery read can answer the missing details.
+---
+
+# Ask Questions If Underspecified
+
+## Goal
+
+Ask the minimum set of clarifying questions needed to avoid wrong work; do not start implementing until the must-have questions are answered (or the user explicitly approves proceeding with stated assumptions).
+
+## Workflow
+
+### 1) Decide whether the request is underspecified
+
+Treat a request as underspecified if after exploring how to perform the work, some or all of the following are not clear:
+- Define the objective (what should change vs stay the same)
+- Define "done" (acceptance criteria, examples, edge cases)
+- Define scope (which files/components/users are in/out)
+- Define constraints (compatibility, performance, style, deps, time)
+- Identify environment (language/runtime versions, OS, build/test runner)
+- Clarify safety/reversibility (data migration, rollout/rollback, risk)
+
+If multiple plausible interpretations exist, assume it is underspecified.
+
+### 2) Ask must-have questions first (keep it small)
+
+Ask 1-5 questions in the first pass. Prefer questions that eliminate whole branches of work.
+
+Use the `question` tool to present structured choices:
+- Offer multiple-choice options with clear labels
+- Mark recommended defaults with "(Recommended)" in the label
+- Use `multiple: true` when the user can select several options
+- The user can always select "Other" for custom input
+
+### 3) Pause before acting
+
+Until must-have answers arrive:
+- Do not run commands, edit files, or produce a detailed plan that depends on unknowns
+- Do perform a clearly labeled, low-risk discovery step only if it does not commit you to a direction (e.g., inspect repo structure, read relevant config files)
+
+If the user explicitly asks you to proceed without answers:
+- State your assumptions as a short numbered list
+- Ask for confirmation; proceed only after they confirm or correct them
+
+### 4) Confirm interpretation, then proceed
+
+Once you have answers, restate the requirements in 1-3 sentences (including key constraints and what success looks like), then start work.
+
+## Anti-patterns
+
+- Don't ask questions you can answer with a quick, low-risk discovery read (e.g., configs, existing patterns, docs).
+- Don't ask open-ended questions if a tight multiple-choice or yes/no would eliminate ambiguity faster.