goatcode-sh 0.0.1 → 0.1.3

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

@@ -0,0 +1,108 @@
+import { describe, it, expect, mock } from "bun:test";
+import { lspSymbolsTool } from "./handler";
+import { createMockToolContext } from "../../../test-utils";
+
+describe("lspSymbolsTool", () => {
+  describe("#given a mock LSP client with document scope", () => {
+    describe("#when symbols are found", () => {
+      it("#then returns formatted symbol list", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspSymbols: mock(async () => ({
+              data: [
+                { name: "MyClass", kind: 5 },
+                { name: "myFunction", kind: 12 },
+              ],
+            })),
+          },
+        } as never);
+
+        const result = await lspSymbolsTool.execute(
+          { filePath: "/src/foo.ts", scope: "document" },
+          ctx,
+        );
+
+        expect(result).toContain("MyClass");
+        expect(result).toContain("myFunction");
+      });
+    });
+
+    describe("#when no symbols are found", () => {
+      it("#then returns 'No symbols found'", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspSymbols: mock(async () => ({ data: [] })),
+          },
+        } as never);
+
+        const result = await lspSymbolsTool.execute(
+          { filePath: "/src/empty.ts", scope: "document" },
+          ctx,
+        );
+
+        expect(result).toBe("No symbols found");
+      });
+    });
+  });
+
+  describe("#given workspace scope", () => {
+    describe("#when query is omitted", () => {
+      it("#then returns an error about missing query", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspSymbols: mock(async () => ({ data: [] })),
+          },
+        } as never);
+
+        const result = await lspSymbolsTool.execute(
+          { filePath: "/src/foo.ts", scope: "workspace" },
+          ctx,
+        );
+
+        expect(result).toBe("Error: 'query' is required for workspace scope");
+      });
+    });
+
+    describe("#when query is provided", () => {
+      it("#then returns formatted results", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspSymbols: mock(async () => ({
+              data: [
+                { name: "handleRequest", kind: 12, location: { uri: "file:///src/server.ts" } },
+              ],
+            })),
+          },
+        } as never);
+
+        const result = await lspSymbolsTool.execute(
+          { filePath: "/src/server.ts", scope: "workspace", query: "handleRequest" },
+          ctx,
+        );
+
+        expect(result).toContain("handleRequest");
+      });
+    });
+  });
+
+  describe("#given the LSP client throws", () => {
+    describe("#when an unexpected error occurs", () => {
+      it("#then returns an error message", async () => {
+        const ctx = createMockToolContext({
+          client: {
+            lspSymbols: mock(async () => {
+              throw new Error("Timeout waiting for response");
+            }),
+          },
+        } as never);
+
+        const result = await lspSymbolsTool.execute(
+          { filePath: "/src/foo.ts", scope: "document" },
+          ctx,
+        );
+
+        expect(result).toBe("Error: Timeout waiting for response");
+      });
+    });
+  });
+});

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

@@ -0,0 +1,43 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+
+import { log } from "../../../shared/logger";
+import { buildTool } from "../../tool-builder";
+import { callLspClient, formatLspResult, getClientFromToolContext } from "../client";
+import { lspSymbolsArgsSchema } from "./types";
+
+const TOOL_NAME = "lsp_symbols";
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export const lspSymbolsTool: ToolDefinition = buildTool({
+  description:
+    "Get symbols from file (document) or search across workspace. Use scope='document' for file outline, scope='workspace' for project-wide symbol search.",
+  args: lspSymbolsArgsSchema.shape as unknown as ToolDefinition["args"],
+  execute: async (args, ctx) => {
+    try {
+      const parsedArgs = lspSymbolsArgsSchema.parse(args);
+      if (parsedArgs.scope === "workspace" && !parsedArgs.query) {
+        return "Error: 'query' is required for workspace scope";
+      }
+
+      const client = getClientFromToolContext(ctx);
+      const result = await callLspClient(client, TOOL_NAME, "lspSymbols", parsedArgs);
+
+      if (
+        result === null ||
+        result === undefined ||
+        (Array.isArray(result) && result.length === 0)
+      ) {
+        return "No symbols found";
+      }
+
+      return formatLspResult(result);
+    } catch (error) {
+      const message = errorMessage(error);
+      log("[lsp_symbols] execution failed", { error: message });
+      return `Error: ${message}`;
+    }
+  },
+});

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

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { lspSymbolsTool } from "./handler";
+
+export const lspSymbolsPlugin = definePlugin({
+  name: "lsp-symbols",
+  version: "0.1.0",
+  tools: {
+    lsp_symbols: lspSymbolsTool,
+  },
+});

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const lspSymbolsArgsSchema = z.object({
+  filePath: z.string().describe("File path for LSP context"),
+  scope: z
+    .enum(["document", "workspace"])
+    .default("document")
+    .describe("'document' for file symbols, 'workspace' for project-wide search"),
+  query: z.string().optional().describe("Symbol name to search (required for workspace scope)"),
+  limit: z.number().optional().describe("Max results (default 50)"),
+});
+
+export type LspSymbolsArgs = z.infer<typeof lspSymbolsArgsSchema>;

package/src/tools/session-manager/client-context.ts

@@ -0,0 +1,16 @@
+import type { OpenCodeContext } from "../../types/plugin";
+
+let storedContext: OpenCodeContext | undefined;
+
+export function initSessionManagerContext(ctx: OpenCodeContext): void {
+  storedContext = ctx;
+}
+
+export function getSessionManagerContext(): OpenCodeContext {
+  if (!storedContext) {
+    throw new Error(
+      "Session manager context not initialized. Call initSessionManagerContext first.",
+    );
+  }
+  return storedContext;
+}

package/src/tools/session-manager/index.ts

@@ -0,0 +1,5 @@
+export { sessionListPlugin } from "./list/plugin";
+export { sessionReadPlugin } from "./read/plugin";
+export { sessionSearchPlugin } from "./search/plugin";
+export { sessionInfoPlugin } from "./info/plugin";
+export { initSessionManagerContext } from "./client-context";

package/src/tools/session-manager/info/handler.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, mock } from "bun:test";
+import type { OpenCodeContext } from "../../../types/plugin";
+import { handleSessionInfo } from "./handler";
+
+const SESSION_ID = "ses_info_test";
+const NOW = 1735000000000;
+const EARLIER = NOW - 86400000;
+
+const mockMessages = [
+  {
+    info: {
+      id: "msg_1",
+      sessionID: SESSION_ID,
+      role: "user" as const,
+      time: { created: EARLIER },
+      agent: "orchestrator",
+    },
+    parts: [
+      {
+        id: "p_1",
+        sessionID: SESSION_ID,
+        messageID: "msg_1",
+        type: "text" as const,
+        text: "Hello",
+      },
+    ],
+  },
+  {
+    info: {
+      id: "msg_2",
+      sessionID: SESSION_ID,
+      role: "assistant" as const,
+      time: { created: NOW },
+    },
+    parts: [
+      {
+        id: "p_2",
+        sessionID: SESSION_ID,
+        messageID: "msg_2",
+        type: "text" as const,
+        text: "Hi there",
+      },
+    ],
+  },
+];
+
+const mockTodos = [
+  { id: "todo_1", content: "Task one", status: "completed", priority: "high" },
+  { id: "todo_2", content: "Task two", status: "pending", priority: "medium" },
+];
+
+function createCtx(): OpenCodeContext {
+  return {
+    directory: "/tmp/test",
+    client: {
+      session: {
+        messages: mock(async (opts: { path: { id: string } }) => {
+          if (opts.path.id === SESSION_ID) return { data: mockMessages };
+          return { data: undefined, error: "not found" };
+        }),
+        todo: mock(async () => ({ data: mockTodos })),
+      },
+    },
+  } as unknown as OpenCodeContext;
+}
+
+describe("handleSessionInfo", () => {
+  describe("#given a session with messages and todos", () => {
+    describe("#when called with its session_id", () => {
+      it("#then returns detailed session metadata", async () => {
+        const ctx = createCtx();
+        const result = await handleSessionInfo({ session_id: SESSION_ID }, ctx);
+        expect(result).toContain(`Session ID: ${SESSION_ID}`);
+        expect(result).toContain("Messages: 2");
+        expect(result).toContain("Agents Used:");
+        expect(result).toContain("orchestrator");
+      });
+    });
+
+    describe("#when the session has todos", () => {
+      it("#then shows the todo summary with counts", async () => {
+        const ctx = createCtx();
+        const result = await handleSessionInfo({ session_id: SESSION_ID }, ctx);
+        expect(result).toContain("Has Todos: Yes");
+        expect(result).toContain("2 items");
+        expect(result).toContain("1 completed");
+      });
+    });
+  });
+
+  describe("#given a non-existent session", () => {
+    describe("#when called with its id", () => {
+      it("#then returns a not found message", async () => {
+        const ctx = createCtx();
+        const result = await handleSessionInfo({ session_id: "ses_does_not_exist" }, ctx);
+        expect(result).toContain("Session not found");
+      });
+    });
+  });
+});

package/src/tools/session-manager/info/handler.ts

@@ -0,0 +1,27 @@
+import type { OpenCodeContext } from "../../../types/plugin";
+import type { Message, Part, Todo } from "@opencode-ai/sdk";
+import type { SessionInfoArgs } from "./types";
+import { buildSessionDetail, formatSessionDetail } from "../session-formatter";
+import { log } from "../../../shared/logger";
+
+export async function handleSessionInfo(
+  args: SessionInfoArgs,
+  ctx: OpenCodeContext,
+): Promise<string> {
+  try {
+    const msgResponse = await ctx.client.session.messages({ path: { id: args.session_id } });
+    if (msgResponse.error) {
+      return `Session not found: ${args.session_id}`;
+    }
+    const messages: Array<{ info: Message; parts: Part[] }> = msgResponse.data ?? [];
+
+    const todoResponse = await ctx.client.session.todo({ path: { id: args.session_id } });
+    const todos: Todo[] = todoResponse.data ?? [];
+
+    const detail = buildSessionDetail(args.session_id, messages, todos, false);
+    return formatSessionDetail(detail);
+  } catch (e) {
+    log("session_info error", e);
+    return `Error: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}

package/src/tools/session-manager/info/plugin.ts

@@ -0,0 +1,40 @@
+import { tool } from "@opencode-ai/plugin";
+import { definePlugin } from "../../../plugin-api/define-plugin";
+import { getSessionManagerContext } from "../client-context";
+import { handleSessionInfo } from "./handler";
+import type { SessionInfoArgs } from "./types";
+
+const SESSION_INFO_DESCRIPTION = `Get metadata and statistics about an OpenCode session.
+
+Returns detailed information about a session including message count, date range, agents used, and available data sources.
+
+Arguments:
+- session_id (required): Session ID to inspect
+
+Example output:
+Session ID: ses_abc123
+Messages: 45
+Date Range: 2025-12-20 to 2025-12-24
+Duration: 4 days, 5 hours
+Agents Used: build, oracle
+Has Todos: Yes (12 items, 8 completed)
+Has Transcript: Yes`;
+
+const sessionInfoTool = tool({
+  description: SESSION_INFO_DESCRIPTION,
+  args: {
+    session_id: tool.schema.string().describe("Session ID to inspect"),
+  },
+  async execute(args: SessionInfoArgs) {
+    const ctx = getSessionManagerContext();
+    return handleSessionInfo(args, ctx);
+  },
+});
+
+export const sessionInfoPlugin = definePlugin({
+  name: "session-info",
+  version: "0.1.0",
+  tools: {
+    session_info: sessionInfoTool,
+  },
+});

package/src/tools/session-manager/info/types.ts

@@ -0,0 +1,3 @@
+export interface SessionInfoArgs {
+  session_id: string;
+}

package/src/tools/session-manager/list/handler.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, mock } from "bun:test";
+import type { OpenCodeContext } from "../../../types/plugin";
+import { handleSessionList } from "./handler";
+
+const NOW = 1735000000000;
+const EARLIER = NOW - 86400000;
+
+const mockSessions = [
+  {
+    id: "ses_aaa",
+    projectID: "proj_1",
+    directory: "/tmp/test",
+    title: "Session A",
+    version: "1.0",
+    time: { created: EARLIER, updated: EARLIER },
+  },
+  {
+    id: "ses_bbb",
+    projectID: "proj_1",
+    directory: "/tmp/test",
+    title: "Session B",
+    version: "1.0",
+    time: { created: NOW, updated: NOW },
+  },
+];
+
+const mockMessages: Record<
+  string,
+  Array<{ info: Record<string, unknown>; parts: Array<Record<string, unknown>> }>
+> = {
+  ses_aaa: [
+    {
+      info: {
+        id: "msg_1",
+        sessionID: "ses_aaa",
+        role: "user",
+        time: { created: EARLIER },
+        agent: "orchestrator",
+      },
+      parts: [{ id: "p_1", sessionID: "ses_aaa", messageID: "msg_1", type: "text", text: "Hello" }],
+    },
+  ],
+  ses_bbb: [
+    {
+      info: {
+        id: "msg_2",
+        sessionID: "ses_bbb",
+        role: "user",
+        time: { created: NOW },
+        agent: "worker",
+      },
+      parts: [{ id: "p_2", sessionID: "ses_bbb", messageID: "msg_2", type: "text", text: "World" }],
+    },
+  ],
+};
+
+function createCtx(overrides: Record<string, unknown> = {}): OpenCodeContext {
+  return {
+    directory: "/tmp/test",
+    client: {
+      session: {
+        list: mock(async () => ({ data: mockSessions })),
+        messages: mock(async (opts: { path: { id: string } }) => ({
+          data: mockMessages[opts.path.id] ?? [],
+        })),
+      },
+    },
+    ...overrides,
+  } as unknown as OpenCodeContext;
+}
+
+describe("handleSessionList", () => {
+  describe("#given sessions exist", () => {
+    describe("#when called with no filters", () => {
+      it("#then returns a formatted table with all sessions", async () => {
+        const ctx = createCtx();
+        const result = await handleSessionList({}, ctx);
+        expect(result).toContain("Session ID");
+        expect(result).toContain("ses_aaa");
+        expect(result).toContain("ses_bbb");
+      });
+    });
+
+    describe("#when called with from_date set to NOW", () => {
+      it("#then only returns sessions updated at or after NOW", async () => {
+        const ctx = createCtx();
+        const result = await handleSessionList({ from_date: new Date(NOW).toISOString() }, ctx);
+        expect(result).toContain("ses_bbb");
+        expect(result).not.toContain("ses_aaa");
+      });
+    });
+
+    describe("#when called with limit=1", () => {
+      it("#then returns only one session row (the newest)", async () => {
+        const ctx = createCtx();
+        const result = await handleSessionList({ limit: 1 }, ctx);
+        const dataLines = result.split("\n").filter((l) => l.startsWith("| ses_"));
+        expect(dataLines.length).toBe(1);
+        expect(result).toContain("ses_bbb");
+        expect(result).not.toContain("ses_aaa");
+      });
+    });
+  });
+
+  describe("#given no sessions exist", () => {
+    describe("#when called", () => {
+      it("#then returns no sessions found message", async () => {
+        const ctx = {
+          directory: "/tmp/test",
+          client: {
+            session: {
+              list: mock(async () => ({ data: [] })),
+              messages: mock(async () => ({ data: [] })),
+            },
+          },
+        } as unknown as OpenCodeContext;
+        const result = await handleSessionList({}, ctx);
+        expect(result).toBe("No sessions found.");
+      });
+    });
+  });
+});

package/src/tools/session-manager/list/handler.ts

@@ -0,0 +1,56 @@
+import type { OpenCodeContext } from "../../../types/plugin";
+import type { Session } from "@opencode-ai/sdk";
+import type { SessionListArgs } from "./types";
+import { buildSessionSummary, formatSessionList } from "../session-formatter";
+import { log } from "../../../shared/logger";
+
+function isAfterDate(session: Session, fromDate: string): boolean {
+  const from = new Date(fromDate).getTime();
+  return session.time.updated >= from;
+}
+
+function isBeforeDate(session: Session, toDate: string): boolean {
+  const to = new Date(toDate).getTime();
+  return session.time.updated <= to;
+}
+
+export async function handleSessionList(
+  args: SessionListArgs,
+  ctx: OpenCodeContext,
+): Promise<string> {
+  try {
+    const directory = args.project_path ?? ctx.directory;
+    const response = await ctx.client.session.list({ query: { directory } });
+    const sessions: Session[] = response.data ?? [];
+
+    let filtered = sessions.filter((s) => !s.parentID);
+
+    if (args.from_date) {
+      filtered = filtered.filter((s) => isAfterDate(s, args.from_date!));
+    }
+
+    if (args.to_date) {
+      filtered = filtered.filter((s) => isBeforeDate(s, args.to_date!));
+    }
+
+    filtered.sort((a, b) => b.time.updated - a.time.updated);
+
+    const MAX_DEFAULT_SESSIONS = 20;
+    filtered =
+      args.limit && args.limit > 0
+        ? filtered.slice(0, args.limit)
+        : filtered.slice(0, MAX_DEFAULT_SESSIONS);
+
+    const summaryPromises = filtered.map(async (session) => {
+      const msgResponse = await ctx.client.session.messages({ path: { id: session.id } });
+      const messages = msgResponse.data ?? [];
+      return buildSessionSummary(session.id, messages);
+    });
+
+    const summaries = await Promise.all(summaryPromises);
+    return formatSessionList(summaries);
+  } catch (e) {
+    log("session_list error", e);
+    return `Error: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}

package/src/tools/session-manager/list/plugin.ts

@@ -0,0 +1,52 @@
+import { tool } from "@opencode-ai/plugin";
+import { definePlugin } from "../../../plugin-api/define-plugin";
+import { getSessionManagerContext } from "../client-context";
+import { handleSessionList } from "./handler";
+import type { SessionListArgs } from "./types";
+
+const SESSION_LIST_DESCRIPTION = `List all OpenCode sessions with optional filtering.
+
+Returns a list of available session IDs with metadata including message count, date range, and agents used.
+
+Arguments:
+- limit (optional): Maximum number of sessions to return
+- from_date (optional): Filter sessions from this date (ISO 8601 format)
+- to_date (optional): Filter sessions until this date (ISO 8601 format)
+- project_path (optional): Filter sessions by project path (default: current working directory)
+
+Example output:
+| Session ID | Messages | First | Last | Agents |
+|------------|----------|-------|------|--------|
+| ses_abc123 | 45 | 2025-12-20 | 2025-12-24 | build, oracle |
+| ses_def456 | 12 | 2025-12-19 | 2025-12-19 | build |`;
+
+const sessionListTool = tool({
+  description: SESSION_LIST_DESCRIPTION,
+  args: {
+    limit: tool.schema.number().optional().describe("Maximum number of sessions to return"),
+    from_date: tool.schema
+      .string()
+      .optional()
+      .describe("Filter sessions from this date (ISO 8601 format)"),
+    to_date: tool.schema
+      .string()
+      .optional()
+      .describe("Filter sessions until this date (ISO 8601 format)"),
+    project_path: tool.schema
+      .string()
+      .optional()
+      .describe("Filter sessions by project path (default: current working directory)"),
+  },
+  async execute(args: SessionListArgs) {
+    const ctx = getSessionManagerContext();
+    return handleSessionList(args, ctx);
+  },
+});
+
+export const sessionListPlugin = definePlugin({
+  name: "session-list",
+  version: "0.1.0",
+  tools: {
+    session_list: sessionListTool,
+  },
+});

package/src/tools/session-manager/list/types.ts

@@ -0,0 +1,6 @@
+export interface SessionListArgs {
+  limit?: number;
+  from_date?: string;
+  to_date?: string;
+  project_path?: string;
+}