goatcode-sh 0.0.1 → 0.1.3

package/src/tools/look-at/look-at.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, mock } from "bun:test";
+import { createLookAtTool } from "./handler";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { PollSnapshot } from "../../runtime";
+
+type ToolContext = Parameters<ToolDefinition["execute"]>[1];
+
+async function noopPoller(fetchSnapshot: () => Promise<PollSnapshot>): Promise<PollSnapshot> {
+  return fetchSnapshot();
+}
+
+function makeToolContext(overrides: Record<string, unknown> = {}): ToolContext {
+  return {
+    sessionID: "session-test",
+    messageID: "message-test",
+    agent: "test-agent",
+    directory: "/tmp",
+    worktree: "/tmp",
+    abort: new AbortController().signal,
+    metadata: () => {},
+    ask: async () => {},
+    ...overrides,
+  } as ToolContext;
+}
+
+function makeClient(sessionOverrides: Record<string, unknown> = {}) {
+  return {
+    session: {
+      create: mock(async () => ({
+        data: { id: "child-session-id" },
+        error: null,
+      })),
+      promptAsync: mock(async () => ({ data: null, error: null })),
+      messages: mock(async () => ({
+        data: [
+          { role: "user", content: "analyze this" },
+          { role: "assistant", content: "Analysis result: found the requested info." },
+        ],
+        error: null,
+      })),
+      status: mock(async () => ({
+        data: { "child-session-id": { type: "idle" } },
+        error: null,
+      })),
+      ...sessionOverrides,
+    },
+  };
+}
+
+function makeContextWithClient(client: ReturnType<typeof makeClient>): ToolContext {
+  return makeToolContext({ client }) as ToolContext;
+}
+
+describe("lookAtTool", () => {
+  describe("#given a text file path and goal", () => {
+    describe("#when the file exists and Inspector agent responds", () => {
+      it("#then it returns the assistant analysis result", async () => {
+        const client = makeClient();
+        const ctx = makeContextWithClient(client);
+        const tool = createLookAtTool(noopPoller);
+
+        await Bun.write("/tmp/look-at-test-file.txt", "Hello, this is test content.");
+
+        const result = await tool.execute(
+          { file_path: "/tmp/look-at-test-file.txt", goal: "find the greeting" },
+          ctx,
+        );
+
+        expect(result).toBe("Analysis result: found the requested info.");
+        expect(client.session.create).toHaveBeenCalledTimes(1);
+        expect(client.session.promptAsync).toHaveBeenCalledTimes(1);
+      });
+    });
+  });
+
+  describe("#given a file path that does not exist", () => {
+    describe("#when execute is called", () => {
+      it("#then it returns a file not found error", async () => {
+        const client = makeClient();
+        const ctx = makeContextWithClient(client);
+        const tool = createLookAtTool(noopPoller);
+
+        const result = await tool.execute(
+          { file_path: "/tmp/nonexistent-look-at-file-xyz.txt", goal: "find something" },
+          ctx,
+        );
+
+        expect(result).toContain("Error: File not found");
+        expect(client.session.create).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given neither file_path nor image_data", () => {
+    describe("#when execute is called", () => {
+      it("#then it returns a validation error", async () => {
+        const client = makeClient();
+        const ctx = makeContextWithClient(client);
+        const tool = createLookAtTool(noopPoller);
+
+        const result = await tool.execute({ goal: "find something" }, ctx);
+
+        expect(result).toContain("Error: Must provide either");
+        expect(client.session.create).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given both file_path and image_data", () => {
+    describe("#when execute is called", () => {
+      it("#then it returns a validation error", async () => {
+        const client = makeClient();
+        const ctx = makeContextWithClient(client);
+        const tool = createLookAtTool(noopPoller);
+
+        const result = await tool.execute(
+          {
+            file_path: "/tmp/some-file.txt",
+            image_data: "data:image/png;base64,abc123",
+            goal: "find something",
+          },
+          ctx,
+        );
+
+        expect(result).toContain("Error: Provide only one of");
+        expect(client.session.create).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given base64 image_data", () => {
+    describe("#when execute is called with a valid base64 image", () => {
+      it("#then it creates a session and returns the analysis", async () => {
+        const client = makeClient();
+        const ctx = makeContextWithClient(client);
+        const tool = createLookAtTool(noopPoller);
+
+        const fakeBase64 =
+          "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+
+        const result = await tool.execute(
+          { image_data: fakeBase64, goal: "describe the image" },
+          ctx,
+        );
+
+        expect(result).toBe("Analysis result: found the requested info.");
+        expect(client.session.create).toHaveBeenCalledTimes(1);
+        expect(client.session.promptAsync).toHaveBeenCalledTimes(1);
+      });
+    });
+  });
+
+  describe("#given session creation fails", () => {
+    describe("#when execute is called", () => {
+      it("#then it returns a session creation error", async () => {
+        const client = makeClient({
+          create: mock(async () => ({ data: null, error: "Unauthorized" })),
+          promptAsync: mock(async () => ({ data: null, error: null })),
+          messages: mock(async () => ({ data: [], error: null })),
+          status: mock(async () => ({ data: {}, error: null })),
+        });
+        const ctx = makeContextWithClient(client);
+        const tool = createLookAtTool(noopPoller);
+
+        await Bun.write("/tmp/look-at-session-fail-test.txt", "content");
+
+        const result = await tool.execute(
+          { file_path: "/tmp/look-at-session-fail-test.txt", goal: "find something" },
+          ctx,
+        );
+
+        expect(result).toContain("Error: Failed to create session");
+      });
+    });
+  });
+
+  describe("#given the Inspector agent returns no assistant message", () => {
+    describe("#when execute is called", () => {
+      it("#then it returns a no response error", async () => {
+        const client = makeClient({
+          messages: mock(async () => ({
+            data: [{ role: "user", content: "analyze this" }],
+            error: null,
+          })),
+        });
+        const ctx = makeContextWithClient(client);
+        const tool = createLookAtTool(noopPoller);
+
+        await Bun.write("/tmp/look-at-no-response-test.txt", "content");
+
+        const result = await tool.execute(
+          { file_path: "/tmp/look-at-no-response-test.txt", goal: "find something" },
+          ctx,
+        );
+
+        expect(result).toContain("Error: No response from Inspector agent");
+      });
+    });
+  });
+});

package/src/tools/look-at/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../plugin-api";
+import { lookAtTool } from "./handler";
+
+export const lookAtPlugin = definePlugin({
+  name: "look-at",
+  version: "0.1.0",
+  tools: {
+    look_at: lookAtTool,
+  },
+});

package/src/tools/look-at/types.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+
+export const lookAtArgsSchema = z.object({
+  file_path: z.string().optional().describe("Absolute path to the file to analyze"),
+  goal: z.string().describe("What specific information to extract from the file"),
+  image_data: z
+    .string()
+    .optional()
+    .describe("Base64 encoded image data (for clipboard/pasted images)"),
+});
+
+export type LookAtArgs = z.infer<typeof lookAtArgsSchema>;
+
+export const LOOK_AT_DESCRIPTION =
+  "Extract basic information from media files (PDFs, images, diagrams) when a quick summary suffices over precise reading. Good for simple text-based content extraction without using the Read tool. NEVER use for visual precision, aesthetic evaluation, or exact accuracy — use Read tool instead for those cases.";
+
+export const LOOK_AT_AGENT_NAME = "advisor";

package/src/tools/lsp/client.ts

@@ -0,0 +1,145 @@
+import type { OpenCodeContext } from "../../types/plugin";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+
+type JsonRecord = Record<string, unknown>;
+
+type ToolCaller = {
+  call?: (input: { name: string; arguments: JsonRecord }) => Promise<unknown>;
+};
+
+function asRecord(value: unknown): JsonRecord | null {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  return value as JsonRecord;
+}
+
+function asFunction(value: unknown): ((...args: unknown[]) => Promise<unknown> | unknown) | null {
+  if (typeof value !== "function") {
+    return null;
+  }
+  return (...args: unknown[]) => value(...args);
+}
+
+function unwrapClientResponse(result: unknown): unknown {
+  const record = asRecord(result);
+  if (!record) {
+    return result;
+  }
+
+  if (record.error !== undefined && record.error !== null) {
+    throw new Error(String(record.error));
+  }
+
+  if ("data" in record) {
+    return record.data;
+  }
+
+  return result;
+}
+
+async function callMethod(
+  methodOwner: JsonRecord,
+  methodName: string,
+  args: JsonRecord,
+): Promise<unknown> {
+  const maybeMethod = asFunction(methodOwner[methodName]);
+  if (!maybeMethod) {
+    return undefined;
+  }
+
+  const methodResult = await maybeMethod(args);
+  return unwrapClientResponse(methodResult);
+}
+
+async function callToolExecutor(
+  toolHost: unknown,
+  toolName: string,
+  args: JsonRecord,
+): Promise<unknown> {
+  const toolRecord = asRecord(toolHost);
+  if (!toolRecord) {
+    return undefined;
+  }
+
+  const caller = toolRecord as ToolCaller;
+  if (!caller.call) {
+    return undefined;
+  }
+
+  const callResult = await caller.call({
+    name: toolName,
+    arguments: args,
+  });
+  return unwrapClientResponse(callResult);
+}
+
+export async function callLspClient(
+  client: OpenCodeContext["client"],
+  toolName: string,
+  directMethodName: string,
+  args: JsonRecord,
+): Promise<unknown> {
+  const clientRecord = asRecord(client);
+  if (!clientRecord) {
+    throw new Error("OpenCode client is unavailable");
+  }
+
+  const directResult = await callMethod(clientRecord, directMethodName, args);
+  if (directResult !== undefined) {
+    return directResult;
+  }
+
+  const lspHost = asRecord(clientRecord.lsp);
+  if (lspHost) {
+    const lspResult = await callMethod(lspHost, directMethodName, args);
+    if (lspResult !== undefined) {
+      return lspResult;
+    }
+
+    const legacyLspResult = await callMethod(lspHost, toolName, args);
+    if (legacyLspResult !== undefined) {
+      return legacyLspResult;
+    }
+  }
+
+  const toolResult = await callToolExecutor(clientRecord.tool, toolName, args);
+  if (toolResult !== undefined) {
+    return toolResult;
+  }
+
+  const toolsResult = await callToolExecutor(clientRecord.tools, toolName, args);
+  if (toolsResult !== undefined) {
+    return toolsResult;
+  }
+
+  throw new Error(`LSP client method unavailable: ${toolName}`);
+}
+
+export function getClientFromToolContext(
+  context: Parameters<ToolDefinition["execute"]>[1],
+): OpenCodeContext["client"] {
+  const contextRecord = asRecord(context);
+  if (!contextRecord) {
+    throw new Error("Tool context is unavailable");
+  }
+
+  const client = contextRecord.client;
+  if (!client) {
+    throw new Error("Tool context does not expose OpenCode client");
+  }
+
+  return client as OpenCodeContext["client"];
+}
+
+export function formatLspResult(result: unknown): string {
+  if (result === null || result === undefined) {
+    return "No result";
+  }
+
+  if (typeof result === "string") {
+    return result;
+  }
+
+  return JSON.stringify(result, null, 2);
+}

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

@@ -0,0 +1,94 @@
+import { describe, it, expect, mock } from "bun:test";
+import { lspDiagnosticsTool } from "./handler";
+import { createMockToolContext } from "../../../test-utils";
+
+describe("lspDiagnosticsTool", () => {
+  describe("#given a mock LSP client", () => {
+    describe("#when diagnostics are found", () => {
+      it("#then returns formatted diagnostics including severity", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspDiagnostics: mock(async () => ({
+              data: [
+                {
+                  severity: "error",
+                  message: "Type 'string' is not assignable to type 'number'",
+                  range: { start: { line: 5, character: 0 } },
+                },
+              ],
+            })),
+          },
+        } as never);
+
+        const result = await lspDiagnosticsTool.execute(
+          { filePath: "/src/index.ts", severity: "error" },
+          ctx,
+        );
+
+        expect(result).toContain("error");
+        expect(result).toContain("not assignable");
+      });
+    });
+
+    describe("#when no diagnostics are found", () => {
+      it("#then returns 'No diagnostics found'", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspDiagnostics: mock(async () => ({ data: [] })),
+          },
+        } as never);
+
+        const result = await lspDiagnosticsTool.execute({ filePath: "/src/clean.ts" }, ctx);
+
+        expect(result).toBe("No diagnostics found");
+      });
+    });
+
+    describe("#when directory with extension is queried", () => {
+      it("#then forwards extension to the LSP client", async () => {
+        const mockFn = mock(async () => ({
+          data: [{ severity: "warning", message: "Unused variable" }],
+        }));
+        const ctx = createMockToolContext({
+          client: { lspDiagnostics: mockFn },
+        } as never);
+
+        const result = await lspDiagnosticsTool.execute(
+          { filePath: "src", extension: ".ts", severity: "warning" },
+          ctx,
+        );
+
+        expect(result).toContain("warning");
+        expect(mockFn).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe("#when the LSP client throws", () => {
+      it("#then returns an error message", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspDiagnostics: mock(async () => {
+              throw new Error("Language server crashed");
+            }),
+          },
+        } as never);
+
+        const result = await lspDiagnosticsTool.execute({ filePath: "/src/index.ts" }, ctx);
+
+        expect(result).toBe("Error: Language server crashed");
+      });
+    });
+  });
+
+  describe("#given invalid arguments", () => {
+    describe("#when filePath is missing", () => {
+      it("#then returns a validation error", async () => {
+        const ctx = createMockToolContext();
+
+        const result = await lspDiagnosticsTool.execute({}, ctx);
+
+        expect(result).toMatch(/^Error:/);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,39 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+
+import { log } from "../../../shared/logger";
+import { buildTool } from "../../tool-builder";
+import { callLspClient, formatLspResult, getClientFromToolContext } from "../client";
+import { lspDiagnosticsArgsSchema } from "./types";
+
+const TOOL_NAME = "lsp_diagnostics";
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export const lspDiagnosticsTool: ToolDefinition = buildTool({
+  description:
+    "Get errors, warnings, hints from language server BEFORE running build. For directories, provide 'extension' parameter (e.g., extension=\".ts\").",
+  args: lspDiagnosticsArgsSchema.shape as unknown as ToolDefinition["args"],
+  execute: async (args, ctx) => {
+    try {
+      const parsedArgs = lspDiagnosticsArgsSchema.parse(args);
+      const client = getClientFromToolContext(ctx);
+      const result = await callLspClient(client, TOOL_NAME, "lspDiagnostics", parsedArgs);
+
+      if (
+        result === null ||
+        result === undefined ||
+        (Array.isArray(result) && result.length === 0)
+      ) {
+        return "No diagnostics found";
+      }
+
+      return formatLspResult(result);
+    } catch (error) {
+      const message = errorMessage(error);
+      log("[lsp_diagnostics] execution failed", { error: message });
+      return `Error: ${message}`;
+    }
+  },
+});

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

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { lspDiagnosticsTool } from "./handler";
+
+export const lspDiagnosticsPlugin = definePlugin({
+  name: "lsp-diagnostics",
+  version: "0.1.0",
+  tools: {
+    lsp_diagnostics: lspDiagnosticsTool,
+  },
+});

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+export const lspDiagnosticsArgsSchema = z.object({
+  filePath: z.string(),
+  severity: z
+    .enum(["error", "warning", "information", "hint", "all"])
+    .optional()
+    .describe("Filter by severity level"),
+  extension: z
+    .string()
+    .optional()
+    .describe("Required if filePath is a directory. E.g., '.ts', '.py', '.go'"),
+});
+
+export type LspDiagnosticsArgs = z.infer<typeof lspDiagnosticsArgsSchema>;

package/src/tools/lsp/find-references/handler.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, mock } from "bun:test";
+import { lspFindReferencesTool } from "./handler";
+import { createMockToolContext } from "../../../test-utils";
+
+describe("lspFindReferencesTool", () => {
+  describe("#given a mock LSP client", () => {
+    describe("#when references are found", () => {
+      it("#then returns formatted result with reference locations", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspFindReferences: mock(async () => ({
+              data: [
+                { uri: "file:///src/a.ts", range: { start: { line: 1, character: 0 } } },
+                { uri: "file:///src/b.ts", range: { start: { line: 5, character: 2 } } },
+              ],
+            })),
+          },
+        } as never);
+
+        const result = await lspFindReferencesTool.execute(
+          { filePath: "/src/a.ts", line: 3, character: 5, includeDeclaration: true },
+          ctx,
+        );
+
+        expect(result).toContain("a.ts");
+        expect(result).toContain("b.ts");
+        expect(result).not.toBe("No references found");
+      });
+    });
+
+    describe("#when no references are found", () => {
+      it("#then returns 'No references found'", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspFindReferences: mock(async () => ({ data: [] })),
+          },
+        } as never);
+
+        const result = await lspFindReferencesTool.execute(
+          { filePath: "/src/a.ts", line: 1, character: 0 },
+          ctx,
+        );
+
+        expect(result).toBe("No references found");
+      });
+    });
+
+    describe("#when the LSP client returns an error response", () => {
+      it("#then returns an error message", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspFindReferences: mock(async () => ({
+              error: "Server not initialized",
+            })),
+          },
+        } as never);
+
+        const result = await lspFindReferencesTool.execute(
+          { filePath: "/src/a.ts", line: 1, character: 0 },
+          ctx,
+        );
+
+        expect(result).toBe("Error: Server not initialized");
+      });
+    });
+  });
+
+  describe("#given invalid arguments", () => {
+    describe("#when filePath is missing", () => {
+      it("#then returns a validation error", async () => {
+        const ctx = createMockToolContext();
+
+        const result = await lspFindReferencesTool.execute({ line: 1, character: 0 }, ctx);
+
+        expect(result).toMatch(/^Error:/);
+      });
+    });
+  });
+});

package/src/tools/lsp/find-references/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 { lspFindReferencesArgsSchema } from "./types";
+
+const TOOL_NAME = "lsp_find_references";
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export const lspFindReferencesTool: ToolDefinition = buildTool({
+  description: "Find ALL usages/references of a symbol across the entire workspace.",
+  args: lspFindReferencesArgsSchema.shape as unknown as ToolDefinition["args"],
+  execute: async (args, ctx) => {
+    try {
+      const parsedArgs = lspFindReferencesArgsSchema.parse(args);
+      const client = getClientFromToolContext(ctx);
+      const result = await callLspClient(client, TOOL_NAME, "lspFindReferences", parsedArgs);
+
+      if (
+        result === null ||
+        result === undefined ||
+        (Array.isArray(result) && result.length === 0)
+      ) {
+        return "No references found";
+      }
+
+      return formatLspResult(result);
+    } catch (error) {
+      const message = errorMessage(error);
+      log("[lsp_find_references] execution failed", { error: message });
+      return `Error: ${message}`;
+    }
+  },
+});

package/src/tools/lsp/find-references/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { lspFindReferencesTool } from "./handler";
+
+export const lspFindReferencesPlugin = definePlugin({
+  name: "lsp-find-references",
+  version: "0.1.0",
+  tools: {
+    lsp_find_references: lspFindReferencesTool,
+  },
+});

package/src/tools/lsp/find-references/types.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const lspFindReferencesArgsSchema = z.object({
+  filePath: z.string(),
+  line: z.number().min(1).describe("1-based"),
+  character: z.number().min(0).describe("0-based"),
+  includeDeclaration: z.boolean().optional().describe("Include the declaration itself"),
+});
+
+export type LspFindReferencesArgs = z.infer<typeof lspFindReferencesArgsSchema>;