@hung319/opencode-hive 1.3.6 → 1.3.8

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)
 
@@ -24624,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",
@@ -25436,6 +25699,12 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         allAgents["hygienic-reviewer"] = builtInAgentConfigs["hygienic-reviewer"];
       }
       Object.assign(allAgents, customSubagents);
+      const primaryAgent = agentMode === "unified" ? "zetta" : "architect-planner";
+      for (const [agentName, agentConfig] of Object.entries(allAgents)) {
+        if (agentName !== primaryAgent && agentConfig && typeof agentConfig === "object") {
+          agentConfig.mode = "subagent";
+        }
+      }
       const configAgent = opencodeConfig.agent;
       if (!configAgent) {
         opencodeConfig.agent = allAgents;
@@ -25453,21 +25722,20 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         delete configAgent["scout-researcher"];
         delete configAgent["forager-worker"];
         delete configAgent["hygienic-reviewer"];
-        if (configAgent.build) {
-          configAgent.build.mode = "subagent";
-        }
-        if (configAgent.plan) {
-          configAgent.plan.mode = "subagent";
-        }
-        if (configAgent.triage) {
-          configAgent.triage.mode = "subagent";
+        const opencodeBuiltInAgents = ["build", "plan", "triage", "docs", "ask", "claude-code"];
+        for (const agentName of opencodeBuiltInAgents) {
+          if (configAgent[agentName]) {
+            configAgent[agentName].mode = "subagent";
+          }
         }
-        if (configAgent.docs) {
-          configAgent.docs.mode = "subagent";
+        for (const [agentName, agentConfig] of Object.entries(allAgents)) {
+          if (agentName !== primaryAgent && agentConfig && typeof agentConfig === "object") {
+            agentConfig.mode = "subagent";
+          }
         }
         Object.assign(configAgent, allAgents);
       }
-      opencodeConfig.default_agent = agentMode === "unified" ? "zetta" : "architect-planner";
+      opencodeConfig.default_agent = primaryAgent;
       const configMcp = opencodeConfig.mcp;
       const mcpToAdd = builtinMcps;
       if (!configMcp) {

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.6",
+  "version": "1.3.8",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",