goatcode-sh 0.0.1 → 0.1.3

package/src/tools/lsp/goto-definition/handler.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, mock } from "bun:test";
+import { lspGotoDefinitionTool } from "./handler";
+import { createMockToolContext } from "../../../test-utils";
+
+describe("lspGotoDefinitionTool", () => {
+  describe("#given a mock LSP client", () => {
+    describe("#when definition is found", () => {
+      it("#then returns formatted result containing the location", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspGotoDefinition: mock(async () => ({
+              data: [
+                {
+                  uri: "file:///src/utils.ts",
+                  range: { start: { line: 10, character: 0 }, end: { line: 10, character: 8 } },
+                },
+              ],
+            })),
+          },
+        } as never);
+
+        const result = await lspGotoDefinitionTool.execute(
+          { filePath: "/src/utils.ts", line: 5, character: 3 },
+          ctx,
+        );
+
+        expect(result).toContain("utils.ts");
+        expect(result).not.toBe("No definition found");
+      });
+    });
+
+    describe("#when no definition is found", () => {
+      it("#then returns 'No definition found'", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspGotoDefinition: mock(async () => ({ data: [] })),
+          },
+        } as never);
+
+        const result = await lspGotoDefinitionTool.execute(
+          { filePath: "/src/foo.ts", line: 1, character: 0 },
+          ctx,
+        );
+
+        expect(result).toBe("No definition found");
+      });
+    });
+
+    describe("#when the LSP client throws", () => {
+      it("#then returns an error message", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspGotoDefinition: mock(async () => {
+              throw new Error("LSP connection lost");
+            }),
+          },
+        } as never);
+
+        const result = await lspGotoDefinitionTool.execute(
+          { filePath: "/src/foo.ts", line: 1, character: 0 },
+          ctx,
+        );
+
+        expect(result).toBe("Error: LSP connection lost");
+      });
+    });
+  });
+
+  describe("#given invalid arguments", () => {
+    describe("#when filePath is missing", () => {
+      it("#then returns a validation error", async () => {
+        const ctx = createMockToolContext();
+
+        const result = await lspGotoDefinitionTool.execute({ line: 1, character: 0 }, ctx);
+
+        expect(result).toMatch(/^Error:/);
+      });
+    });
+  });
+});

package/src/tools/lsp/goto-definition/handler.ts

@@ -0,0 +1,38 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { log } from "../../../shared/logger";
+import { buildTool } from "../../tool-builder";
+import { callLspClient, formatLspResult, getClientFromToolContext } from "../client";
+import type { LspGotoDefinitionArgs } from "./types";
+import { lspGotoDefinitionArgsSchema } from "./types";
+
+const TOOL_NAME = "lsp_goto_definition";
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export const lspGotoDefinitionTool: ToolDefinition = buildTool({
+  description: "Jump to symbol definition. Find WHERE something is defined.",
+  args: lspGotoDefinitionArgsSchema.shape as unknown as ToolDefinition["args"],
+  execute: async (args, ctx) => {
+    try {
+      const parsedArgs = lspGotoDefinitionArgsSchema.parse(args) as LspGotoDefinitionArgs;
+      const client = getClientFromToolContext(ctx);
+      const result = await callLspClient(client, TOOL_NAME, "lspGotoDefinition", parsedArgs);
+
+      if (
+        result === null ||
+        result === undefined ||
+        (Array.isArray(result) && result.length === 0)
+      ) {
+        return "No definition found";
+      }
+
+      return formatLspResult(result);
+    } catch (error) {
+      const message = errorMessage(error);
+      log("[lsp_goto_definition] execution failed", { error: message });
+      return `Error: ${message}`;
+    }
+  },
+});

package/src/tools/lsp/goto-definition/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { lspGotoDefinitionTool } from "./handler";
+
+export const lspGotoDefinitionPlugin = definePlugin({
+  name: "lsp-goto-definition",
+  version: "0.1.0",
+  tools: {
+    lsp_goto_definition: lspGotoDefinitionTool,
+  },
+});

package/src/tools/lsp/goto-definition/types.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const lspGotoDefinitionArgsSchema = z.object({
+  filePath: z.string(),
+  line: z.number().min(1).describe("1-based"),
+  character: z.number().min(0).describe("0-based"),
+});
+
+export type LspGotoDefinitionArgs = z.infer<typeof lspGotoDefinitionArgsSchema>;

package/src/tools/lsp/index.ts

@@ -0,0 +1,6 @@
+export { lspGotoDefinitionPlugin } from "./goto-definition/plugin";
+export { lspFindReferencesPlugin } from "./find-references/plugin";
+export { lspSymbolsPlugin } from "./symbols/plugin";
+export { lspDiagnosticsPlugin } from "./diagnostics/plugin";
+export { lspPrepareRenamePlugin } from "./prepare-rename/plugin";
+export { lspRenamePlugin } from "./rename/plugin";

package/src/tools/lsp/lsp-tools.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect, mock } from "bun:test";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+
+import { lspGotoDefinitionPlugin } from "./goto-definition/plugin";
+import { lspFindReferencesPlugin } from "./find-references/plugin";
+import { lspSymbolsPlugin } from "./symbols/plugin";
+import { lspDiagnosticsPlugin } from "./diagnostics/plugin";
+import { lspPrepareRenamePlugin } from "./prepare-rename/plugin";
+import { lspRenamePlugin } from "./rename/plugin";
+
+type ToolContext = Parameters<ToolDefinition["execute"]>[1];
+
+function createToolContext(result: unknown) {
+  const call = mock(async () => ({ data: result }));
+  const context = {
+    client: {
+      tool: { call },
+    },
+  } as unknown as ToolContext;
+  return { call, context };
+}
+
+describe("lsp tool plugins", () => {
+  describe("#given lsp_goto_definition plugin", () => {
+    describe("#when tool executes through client proxy", () => {
+      it("#then it calls client.tool.call with lsp_goto_definition", async () => {
+        const tool = lspGotoDefinitionPlugin.tools!.lsp_goto_definition;
+        const { call, context } = createToolContext([{ filePath: "a.ts", line: 7 }]);
+
+        const result = await tool.execute({ filePath: "a.ts", line: 1, character: 0 }, context);
+
+        expect(call).toHaveBeenCalledTimes(1);
+        expect(call.mock.calls[0]?.[0]).toEqual({
+          name: "lsp_goto_definition",
+          arguments: { filePath: "a.ts", line: 1, character: 0 },
+        });
+        expect(result).toContain("a.ts");
+      });
+    });
+  });
+
+  describe("#given lsp_find_references plugin", () => {
+    describe("#when tool executes through client proxy", () => {
+      it("#then it calls client.tool.call with lsp_find_references", async () => {
+        const tool = lspFindReferencesPlugin.tools!.lsp_find_references;
+        const { call, context } = createToolContext([{ filePath: "a.ts", line: 9 }]);
+
+        const result = await tool.execute(
+          { filePath: "a.ts", line: 2, character: 3, includeDeclaration: true },
+          context,
+        );
+
+        expect(call).toHaveBeenCalledTimes(1);
+        expect(call.mock.calls[0]?.[0]).toEqual({
+          name: "lsp_find_references",
+          arguments: { filePath: "a.ts", line: 2, character: 3, includeDeclaration: true },
+        });
+        expect(result).toContain("a.ts");
+      });
+    });
+  });
+
+  describe("#given lsp_symbols plugin", () => {
+    describe("#when workspace scope omits query", () => {
+      it("#then it returns a validation message", async () => {
+        const tool = lspSymbolsPlugin.tools!.lsp_symbols;
+        const { context } = createToolContext([]);
+
+        const result = await tool.execute({ filePath: "a.ts", scope: "workspace" }, context);
+
+        expect(result).toBe("Error: 'query' is required for workspace scope");
+      });
+    });
+
+    describe("#when document scope executes through client proxy", () => {
+      it("#then it calls client.tool.call with lsp_symbols", async () => {
+        const tool = lspSymbolsPlugin.tools!.lsp_symbols;
+        const { call, context } = createToolContext([{ name: "myFunc" }]);
+
+        const result = await tool.execute(
+          { filePath: "a.ts", scope: "document", limit: 10 },
+          context,
+        );
+
+        expect(call.mock.calls[0]?.[0]).toEqual({
+          name: "lsp_symbols",
+          arguments: { filePath: "a.ts", scope: "document", limit: 10 },
+        });
+        expect(result).toContain("myFunc");
+      });
+    });
+  });
+
+  describe("#given lsp_diagnostics plugin", () => {
+    describe("#when directory-level args are provided", () => {
+      it("#then it forwards extension and severity to client", async () => {
+        const tool = lspDiagnosticsPlugin.tools!.lsp_diagnostics;
+        const { call, context } = createToolContext([{ severity: "warning" }]);
+
+        const result = await tool.execute(
+          { filePath: "src", extension: ".ts", severity: "warning" },
+          context,
+        );
+
+        expect(call.mock.calls[0]?.[0]).toEqual({
+          name: "lsp_diagnostics",
+          arguments: { filePath: "src", extension: ".ts", severity: "warning" },
+        });
+        expect(result).toContain("warning");
+      });
+    });
+  });
+
+  describe("#given lsp_prepare_rename plugin", () => {
+    describe("#when tool executes through client proxy", () => {
+      it("#then it calls client.tool.call with lsp_prepare_rename", async () => {
+        const tool = lspPrepareRenamePlugin.tools!.lsp_prepare_rename;
+        const { call, context } = createToolContext({ range: { start: 1, end: 2 } });
+
+        const result = await tool.execute({ filePath: "a.ts", line: 10, character: 5 }, context);
+
+        expect(call.mock.calls[0]?.[0]).toEqual({
+          name: "lsp_prepare_rename",
+          arguments: { filePath: "a.ts", line: 10, character: 5 },
+        });
+        expect(result).toContain("range");
+      });
+    });
+  });
+
+  describe("#given lsp_rename plugin", () => {
+    describe("#when tool executes through client proxy", () => {
+      it("#then it calls client.tool.call with lsp_rename", async () => {
+        const tool = lspRenamePlugin.tools!.lsp_rename;
+        const { call, context } = createToolContext({ changes: { "a.ts": [] } });
+
+        const result = await tool.execute(
+          { filePath: "a.ts", line: 12, character: 1, newName: "nextName" },
+          context,
+        );
+
+        expect(call.mock.calls[0]?.[0]).toEqual({
+          name: "lsp_rename",
+          arguments: { filePath: "a.ts", line: 12, character: 1, newName: "nextName" },
+        });
+        expect(result).toContain("changes");
+      });
+    });
+  });
+});

package/src/tools/lsp/prepare-rename/handler.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, mock } from "bun:test";
+import { lspPrepareRenameTool } from "./handler";
+import { createMockToolContext } from "../../../test-utils";
+
+describe("lspPrepareRenameTool", () => {
+  describe("#given a mock LSP client", () => {
+    describe("#when rename is valid at position", () => {
+      it("#then returns formatted rename preparation result", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspPrepareRename: mock(async () => ({
+              data: {
+                range: { start: { line: 10, character: 4 }, end: { line: 10, character: 12 } },
+                placeholder: "oldName",
+              },
+            })),
+          },
+        } as never);
+
+        const result = await lspPrepareRenameTool.execute(
+          { filePath: "/src/foo.ts", line: 10, character: 5 },
+          ctx,
+        );
+
+        expect(result).toContain("oldName");
+        expect(result).toContain("range");
+      });
+    });
+
+    describe("#when rename is not valid at position", () => {
+      it("#then returns 'Rename is not valid at this position'", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspPrepareRename: mock(async () => ({ data: null })),
+          },
+        } as never);
+
+        const result = await lspPrepareRenameTool.execute(
+          { filePath: "/src/foo.ts", line: 1, character: 0 },
+          ctx,
+        );
+
+        expect(result).toBe("Rename is not valid at this position");
+      });
+    });
+
+    describe("#when the LSP client throws", () => {
+      it("#then returns an error message", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspPrepareRename: mock(async () => {
+              throw new Error("Method not supported");
+            }),
+          },
+        } as never);
+
+        const result = await lspPrepareRenameTool.execute(
+          { filePath: "/src/foo.ts", line: 1, character: 0 },
+          ctx,
+        );
+
+        expect(result).toBe("Error: Method not supported");
+      });
+    });
+  });
+
+  describe("#given invalid arguments", () => {
+    describe("#when line is zero", () => {
+      it("#then returns a validation error for min constraint", async () => {
+        const ctx = createMockToolContext();
+
+        const result = await lspPrepareRenameTool.execute(
+          { filePath: "/src/foo.ts", line: 0, character: 0 },
+          ctx,
+        );
+
+        expect(result).toMatch(/^Error:/);
+      });
+    });
+  });
+});

package/src/tools/lsp/prepare-rename/handler.ts

@@ -0,0 +1,34 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+
+import { log } from "../../../shared/logger";
+import { buildTool } from "../../tool-builder";
+import { callLspClient, formatLspResult, getClientFromToolContext } from "../client";
+import { lspPrepareRenameArgsSchema } from "./types";
+
+const TOOL_NAME = "lsp_prepare_rename";
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export const lspPrepareRenameTool: ToolDefinition = buildTool({
+  description: "Check if rename is valid. Use BEFORE lsp_rename.",
+  args: lspPrepareRenameArgsSchema.shape as unknown as ToolDefinition["args"],
+  execute: async (args, ctx) => {
+    try {
+      const parsedArgs = lspPrepareRenameArgsSchema.parse(args);
+      const client = getClientFromToolContext(ctx);
+      const result = await callLspClient(client, TOOL_NAME, "lspPrepareRename", parsedArgs);
+
+      if (result === null || result === undefined) {
+        return "Rename is not valid at this position";
+      }
+
+      return formatLspResult(result);
+    } catch (error) {
+      const message = errorMessage(error);
+      log("[lsp_prepare_rename] execution failed", { error: message });
+      return `Error: ${message}`;
+    }
+  },
+});

package/src/tools/lsp/prepare-rename/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { lspPrepareRenameTool } from "./handler";
+
+export const lspPrepareRenamePlugin = definePlugin({
+  name: "lsp-prepare-rename",
+  version: "0.1.0",
+  tools: {
+    lsp_prepare_rename: lspPrepareRenameTool,
+  },
+});

package/src/tools/lsp/prepare-rename/types.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const lspPrepareRenameArgsSchema = z.object({
+  filePath: z.string(),
+  line: z.number().min(1).describe("1-based"),
+  character: z.number().min(0).describe("0-based"),
+});
+
+export type LspPrepareRenameArgs = z.infer<typeof lspPrepareRenameArgsSchema>;

package/src/tools/lsp/rename/handler.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, mock } from "bun:test";
+import { lspRenameTool } from "./handler";
+import { createMockToolContext } from "../../../test-utils";
+
+describe("lspRenameTool", () => {
+  describe("#given a mock LSP client", () => {
+    describe("#when rename produces changes", () => {
+      it("#then returns formatted workspace edit", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspRename: mock(async () => ({
+              data: {
+                changes: {
+                  "file:///src/foo.ts": [
+                    {
+                      range: { start: { line: 1, character: 4 }, end: { line: 1, character: 11 } },
+                      newText: "newName",
+                    },
+                  ],
+                },
+              },
+            })),
+          },
+        } as never);
+
+        const result = await lspRenameTool.execute(
+          { filePath: "/src/foo.ts", line: 1, character: 4, newName: "newName" },
+          ctx,
+        );
+
+        expect(result).toContain("changes");
+        expect(result).toContain("newName");
+      });
+    });
+
+    describe("#when no rename changes are produced", () => {
+      it("#then returns 'No rename changes produced'", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspRename: mock(async () => ({ data: null })),
+          },
+        } as never);
+
+        const result = await lspRenameTool.execute(
+          { filePath: "/src/foo.ts", line: 1, character: 0, newName: "newName" },
+          ctx,
+        );
+
+        expect(result).toBe("No rename changes produced");
+      });
+    });
+
+    describe("#when the LSP client returns an error response", () => {
+      it("#then returns an error message", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspRename: mock(async () => ({
+              error: "Cannot rename: symbol is read-only",
+            })),
+          },
+        } as never);
+
+        const result = await lspRenameTool.execute(
+          { filePath: "/src/foo.ts", line: 1, character: 0, newName: "newName" },
+          ctx,
+        );
+
+        expect(result).toBe("Error: Cannot rename: symbol is read-only");
+      });
+    });
+  });
+
+  describe("#given invalid arguments", () => {
+    describe("#when newName is missing", () => {
+      it("#then returns a validation error", async () => {
+        const ctx = createMockToolContext();
+
+        const result = await lspRenameTool.execute(
+          { filePath: "/src/foo.ts", line: 1, character: 0 },
+          ctx,
+        );
+
+        expect(result).toMatch(/^Error:/);
+      });
+    });
+  });
+});

package/src/tools/lsp/rename/handler.ts

@@ -0,0 +1,34 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+
+import { log } from "../../../shared/logger";
+import { buildTool } from "../../tool-builder";
+import { callLspClient, formatLspResult, getClientFromToolContext } from "../client";
+import { lspRenameArgsSchema } from "./types";
+
+const TOOL_NAME = "lsp_rename";
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export const lspRenameTool: ToolDefinition = buildTool({
+  description: "Rename symbol across entire workspace. APPLIES changes to all files.",
+  args: lspRenameArgsSchema.shape as unknown as ToolDefinition["args"],
+  execute: async (args, ctx) => {
+    try {
+      const parsedArgs = lspRenameArgsSchema.parse(args);
+      const client = getClientFromToolContext(ctx);
+      const result = await callLspClient(client, TOOL_NAME, "lspRename", parsedArgs);
+
+      if (result === null || result === undefined) {
+        return "No rename changes produced";
+      }
+
+      return formatLspResult(result);
+    } catch (error) {
+      const message = errorMessage(error);
+      log("[lsp_rename] execution failed", { error: message });
+      return `Error: ${message}`;
+    }
+  },
+});

package/src/tools/lsp/rename/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { lspRenameTool } from "./handler";
+
+export const lspRenamePlugin = definePlugin({
+  name: "lsp-rename",
+  version: "0.1.0",
+  tools: {
+    lsp_rename: lspRenameTool,
+  },
+});

package/src/tools/lsp/rename/types.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const lspRenameArgsSchema = z.object({
+  filePath: z.string(),
+  line: z.number().min(1).describe("1-based"),
+  character: z.number().min(0).describe("0-based"),
+  newName: z.string().describe("New symbol name"),
+});
+
+export type LspRenameArgs = z.infer<typeof lspRenameArgsSchema>;