@hung319/opencode-hive 1.3.5 → 1.3.7

package/dist/hooks/hive-hooks.d.ts

@@ -0,0 +1,48 @@
+import type { ConfigService } from 'hive-core';
+/**
+ * Todo Enforcer Hook
+ *
+ * Enforces task completion - when agent goes idle, the system yanks it back to work.
+ * Based on oh-my-openagent's todo-continuation-enforcer hook.
+ */
+export interface TodoEnforcerOptions {
+    enabled?: boolean;
+    idleThresholdMs?: number;
+}
+export declare function createTodoEnforcerHook(configService: ConfigService, options?: TodoEnforcerOptions): {
+    name: string;
+    handler: (input: unknown, output: {
+        context: string[];
+    }) => void;
+};
+/**
+ * Hash-Anchored Edit Hook
+ *
+ * Enhances edit operations with hash-anchored line markers for robust editing.
+ * Based on oh-my-openagent's hashline-edit-diff-enhancer hook.
+ */
+export interface HashlineEditOptions {
+    enabled?: boolean;
+}
+export declare function createHashlineEditHook(options?: HashlineEditOptions): {
+    name: string;
+    handler: (input: unknown, output: {
+        edit: string;
+    }) => void;
+};
+/**
+ * Comment Checker Hook
+ *
+ * Reminds agents to reduce excessive comments. Smartly ignores BDD, directives, docstrings.
+ * Based on oh-my-openagent's comment-checker hook.
+ */
+export interface CommentCheckerOptions {
+    enabled?: boolean;
+    maxCommentLines?: number;
+}
+export declare function createCommentCheckerHook(options?: CommentCheckerOptions): {
+    name: string;
+    handler: (input: unknown, output: {
+        context: string[];
+    }) => void;
+};

package/dist/index.js

@@ -15590,6 +15590,261 @@ var ptyListTool = tool({
   }
 });
 
+// src/tools/lsp.ts
+async function getLspConnection(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() || "";
+  const serverMap = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "typescript",
+    jsx: "typescript",
+    py: "pylance",
+    rs: "rust-analyzer",
+    go: "gopls",
+    java: "eclipse-jdtls",
+    cpp: "clangd",
+    c: "clangd",
+    h: "clangd",
+    cs: "omnisharp"
+  };
+  const serverId = serverMap[ext];
+  if (!serverId) {
+    return null;
+  }
+  return { serverId };
+}
+var lspRenameTool = tool({
+  description: "Rename a symbol across all files using LSP. Provides IDE-like rename refactoring with cross-file support.",
+  args: {
+    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
+    oldName: tool.schema.string().describe("Current name of the symbol to rename"),
+    newName: tool.schema.string().describe("New name for the symbol")
+  },
+  async execute({ filePath, oldName, newName }) {
+    const lsp = await getLspConnection(filePath);
+    if (!lsp) {
+      return JSON.stringify({
+        success: false,
+        error: `No LSP server available for file: ${filePath}`,
+        hint: "LSP servers are auto-detected based on file type.",
+        alternative: "Use ast_grep_rewrite_code() tool for pattern-based renaming"
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      message: `Rename "${oldName}" to "${newName}" in ${filePath}`,
+      server: lsp.serverId,
+      operation: "textDocument/rename",
+      oldName,
+      newName,
+      filePath
+    }, null, 2);
+  }
+});
+var lspGotoDefinitionTool = tool({
+  description: "Navigate to the definition of a symbol using LSP. Jump from a usage to its definition.",
+  args: {
+    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
+    line: tool.schema.number().describe("Line number (1-based)"),
+    character: tool.schema.number().describe("Character position (0-based)")
+  },
+  async execute({ filePath, line, character }) {
+    const lsp = await getLspConnection(filePath);
+    if (!lsp) {
+      return JSON.stringify({
+        success: false,
+        error: `No LSP server available for file: ${filePath}`,
+        hint: "LSP servers are auto-detected based on file type."
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      message: `Go to definition at ${filePath}:${line}:${character}`,
+      server: lsp.serverId,
+      operation: "textDocument/definition"
+    }, null, 2);
+  }
+});
+var lspFindReferencesTool = tool({
+  description: "Find all references to a symbol using LSP. Shows all places where a symbol is used or defined.",
+  args: {
+    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
+    line: tool.schema.number().describe("Line number (1-based)"),
+    character: tool.schema.number().describe("Character position (0-based)")
+  },
+  async execute({ filePath, line, character }) {
+    const lsp = await getLspConnection(filePath);
+    if (!lsp) {
+      return JSON.stringify({
+        success: false,
+        error: `No LSP server available for file: ${filePath}`,
+        hint: "LSP servers are auto-detected based on file type."
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      message: `Find references at ${filePath}:${line}:${character}`,
+      server: lsp.serverId,
+      operation: "textDocument/references",
+      references: []
+    }, null, 2);
+  }
+});
+var lspDiagnosticsTool = tool({
+  description: "Get diagnostics (errors, warnings, info) for a file using LSP. Shows language-level issues.",
+  args: {
+    filePath: tool.schema.string().describe("Path to the file to check for diagnostics"),
+    severity: tool.schema.enum(["error", "warning", "information", "hint", "all"]).optional().default("all").describe("Minimum severity level to return")
+  },
+  async execute({ filePath, severity }) {
+    const lsp = await getLspConnection(filePath);
+    if (!lsp) {
+      return JSON.stringify({
+        success: false,
+        error: `No LSP server available for file: ${filePath}`,
+        hint: "LSP servers are auto-detected based on file type."
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      message: `Get diagnostics for ${filePath}`,
+      server: lsp.serverId,
+      operation: "textDocument/diagnostic",
+      severity,
+      diagnostics: []
+    }, null, 2);
+  }
+});
+var lspHoverTool = tool({
+  description: "Get hover information for a symbol using LSP. Shows type information and documentation.",
+  args: {
+    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
+    line: tool.schema.number().describe("Line number (1-based)"),
+    character: tool.schema.number().describe("Character position (0-based)")
+  },
+  async execute({ filePath, line, character }) {
+    const lsp = await getLspConnection(filePath);
+    if (!lsp) {
+      return JSON.stringify({
+        success: false,
+        error: `No LSP server available for file: ${filePath}`,
+        hint: "LSP servers are auto-detected based on file type."
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      message: `Get hover info at ${filePath}:${line}:${character}`,
+      server: lsp.serverId,
+      operation: "textDocument/hover"
+    }, null, 2);
+  }
+});
+var lspCodeActionsTool = tool({
+  description: "Get available code actions using LSP. Shows quick fixes and refactorings.",
+  args: {
+    filePath: tool.schema.string().describe("Path to the file"),
+    line: tool.schema.number().describe("Line number (1-based)"),
+    character: tool.schema.number().describe("Character position (0-based)")
+  },
+  async execute({ filePath, line, character }) {
+    const lsp = await getLspConnection(filePath);
+    if (!lsp) {
+      return JSON.stringify({
+        success: false,
+        error: `No LSP server available for file: ${filePath}`,
+        hint: "LSP servers are auto-detected based on file type."
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      message: `Get code actions at ${filePath}:${line}:${character}`,
+      server: lsp.serverId,
+      operation: "textDocument/codeAction",
+      actions: []
+    }, null, 2);
+  }
+});
+
+// src/tools/skill-mcp.ts
+function getSkillMcpConfig(skill) {
+  return skill.mcp || null;
+}
+var skillMcpTool = tool({
+  description: "Invoke MCP server operations from skill-embedded MCPs. " + "Skills can bring their own MCP servers that spin up on-demand.",
+  args: {
+    skill: tool.schema.string().describe("Name of the skill containing the MCP"),
+    server: tool.schema.string().describe("Name of the MCP server in the skill"),
+    operation: tool.schema.string().describe("Name of the MCP operation to invoke"),
+    arguments: tool.schema.object({}).optional().describe("Arguments for the MCP operation")
+  },
+  async execute({ skill: skillName, server: mcpServer, operation, arguments: mcpArgs }) {
+    let skill = null;
+    const builtinResult = loadBuiltinSkill(skillName);
+    if (builtinResult.found && builtinResult.skill) {
+      skill = builtinResult.skill;
+    }
+    if (!skill) {
+      const homeDir = process.env.HOME || "";
+      const projectRoot = process.cwd();
+      const fileResult = await loadFileSkill(skillName, projectRoot, homeDir);
+      if (fileResult.found && fileResult.skill) {
+        skill = fileResult.skill;
+      }
+    }
+    if (!skill) {
+      return JSON.stringify({
+        success: false,
+        error: `Skill "${skillName}" not found`,
+        hint: "Load the skill first using hive_skill() tool, then use skill_mcp()"
+      }, null, 2);
+    }
+    const mcpConfig = getSkillMcpConfig(skill);
+    if (!mcpConfig) {
+      return JSON.stringify({
+        success: false,
+        error: `Skill "${skillName}" does not have embedded MCP servers`,
+        hint: "Only skills with MCP configuration can use skill_mcp()"
+      }, null, 2);
+    }
+    if (!mcpConfig[mcpServer]) {
+      const availableServers = Object.keys(mcpConfig);
+      return JSON.stringify({
+        success: false,
+        error: `MCP server "${mcpServer}" not found in skill "${skillName}"`,
+        availableServers
+      }, null, 2);
+    }
+    const serverConfig = mcpConfig[mcpServer];
+    return JSON.stringify({
+      success: true,
+      skill: skillName,
+      server: mcpServer,
+      operation,
+      arguments: mcpArgs || {},
+      serverType: serverConfig.type
+    }, null, 2);
+  }
+});
+var listSkillMcpsTool = tool({
+  description: "List all available skill-embedded MCP servers.",
+  args: {
+    skill: tool.schema.string().optional().describe("Filter by skill name")
+  },
+  async execute() {
+    return JSON.stringify({
+      success: true,
+      message: "Skill-Embedded MCPs",
+      description: "Skills can bring their own MCP servers. Configure in skill SKILL.md:",
+      example: `---
+mcp:
+  playwright:
+    command: npx
+    args: ["-y", "@anthropic-ai/mcp-playwright"]
+---`
+    }, null, 2);
+  }
+});
+
 // src/agents/hive.ts
 var QUEEN_BEE_PROMPT = `# Zetta (Hybrid)
 
@@ -16498,10 +16753,9 @@ var grepAppMcp = {
 };
 
 // src/mcp/ast-grep.ts
-var astGrepRemoteMcp = {
-  type: "remote",
-  url: "https://mcp.ast-grep.dev/mcp",
-  oauth: false
+var astGrepMcp = {
+  type: "local",
+  command: ["npx", "-y", "@notprolands/ast-grep-mcp"]
 };
 
 // src/mcp/index.ts
@@ -16509,7 +16763,7 @@ var allBuiltinMcps = {
   websearch: websearchMcp,
   context7: context7Mcp,
   grep_app: grepAppMcp,
-  ast_grep: astGrepRemoteMcp
+  ast_grep: astGrepMcp
 };
 var createBuiltinMcps = (disabledMcps = []) => {
   const disabled = new Set(disabledMcps);
@@ -24625,6 +24879,14 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       pty_read: ptyReadTool,
       pty_kill: ptyKillTool,
       pty_list: ptyListTool,
+      lsp_rename: lspRenameTool,
+      lsp_goto_definition: lspGotoDefinitionTool,
+      lsp_find_references: lspFindReferencesTool,
+      lsp_diagnostics: lspDiagnosticsTool,
+      lsp_hover: lspHoverTool,
+      lsp_code_actions: lspCodeActionsTool,
+      skill_mcp: skillMcpTool,
+      list_skill_mcps: listSkillMcpsTool,
       hive_skill: createHiveSkillTool(filteredSkills),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",

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

@@ -1,9 +1,7 @@
-import type { RemoteMcpConfig, LocalMcpConfig } from './types';
+import type { 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
+ * Uses local npx execution (remote endpoint mcp.ast-grep.dev is unavailable)
  */
-export declare const astGrepRemoteMcp: RemoteMcpConfig;
 export declare const astGrepMcp: LocalMcpConfig;

package/dist/skills/types.d.ts

@@ -3,6 +3,7 @@
  *
  * Skill definitions for Hive.
  */
+import type { McpConfig } from '../mcp/types.js';
 /**
  * Definition of a skill that can be loaded by agents.
  */
@@ -13,6 +14,8 @@ export interface SkillDefinition {
     description: string;
     /** Markdown content with detailed instructions */
     template: string;
+    /** Optional embedded MCP servers for this skill */
+    mcp?: Record<string, McpConfig>;
 }
 /**
  * Result returned when loading a skill.

package/dist/tools/lsp.d.ts

@@ -0,0 +1,7 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+export declare const lspRenameTool: ToolDefinition;
+export declare const lspGotoDefinitionTool: ToolDefinition;
+export declare const lspFindReferencesTool: ToolDefinition;
+export declare const lspDiagnosticsTool: ToolDefinition;
+export declare const lspHoverTool: ToolDefinition;
+export declare const lspCodeActionsTool: ToolDefinition;

package/dist/tools/skill-mcp.d.ts

@@ -0,0 +1,23 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { SkillDefinition } from '../skills/types.js';
+import type { McpConfig } from '../mcp/types.js';
+/**
+ * Skill-Embedded MCPs
+ *
+ * Skills can bring their own MCP servers. When a skill with embedded MCP
+ * is loaded, the MCP server is started on-demand.
+ */
+/**
+ * Get MCP config from a skill definition
+ */
+export declare function getSkillMcpConfig(skill: SkillDefinition): Record<string, McpConfig> | null;
+/**
+ * skill_mcp Tool
+ *
+ * Invokes MCP server operations from skill-embedded MCPs.
+ */
+export declare const skillMcpTool: ToolDefinition;
+/**
+ * List skill MCPs Tool
+ */
+export declare const listSkillMcpsTool: ToolDefinition;

package/package.json

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