goatcode-sh 0.0.1 → 0.1.2

package/src/test-utils/mock-hook-inputs.ts

@@ -0,0 +1,148 @@
+/**
+ * Mock factory functions for all 16 hook event input shapes.
+ * Each factory: `make{EventName}Input(overrides?)` returning the typed input object.
+ */
+
+export function makeToolInput(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeConfigInput(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeChatMessageInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    sessionID: "ses_test",
+    ...overrides,
+  };
+}
+
+export function makeChatParamsInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    sessionID: "ses_test",
+    agent: { id: "agent_test", type: "user" },
+    model: {
+      providerID: "anthropic",
+      modelID: "claude-3-5-sonnet",
+      provider: { id: "anthropic" },
+    },
+    ...overrides,
+  };
+}
+
+export function makeChatHeadersInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeEventInput(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    event: {
+      type: "session.created",
+      properties: {
+        info: {
+          id: "evt_test",
+        },
+      },
+    },
+    ...overrides,
+  };
+}
+
+export function makeToolExecuteBeforeInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    tool: "edit",
+    sessionID: "ses_test",
+    ...overrides,
+  };
+}
+
+export function makeToolExecuteAfterInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    tool: "edit",
+    sessionID: "ses_test",
+    callID: "call_test",
+    ...overrides,
+  };
+}
+
+export function makeExperimentalChatMessagesTransformInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeExperimentalChatSystemTransformInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    tool: "delegate-task",
+    ...overrides,
+  };
+}
+
+export function makeToolDefinitionInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makePermissionAskInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeCommandExecuteBeforeInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeShellEnvInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeExperimentalSessionCompactingInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeExperimentalTextCompleteInput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}

package/src/test-utils/mock-hook-outputs.ts

@@ -0,0 +1,153 @@
+/**
+ * Mock factory functions for all 16 hook event output shapes.
+ * Outputs are mutable objects that hooks modify in-place.
+ */
+
+export function makeToolOutput(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeConfigOutput(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeChatMessageOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    parts: [
+      {
+        type: "text",
+        text: "test message",
+      },
+    ],
+    ...overrides,
+  };
+}
+
+export function makeChatParamsOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    options: {},
+    ...overrides,
+  };
+}
+
+export function makeChatHeadersOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeEventOutput(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeToolExecuteBeforeOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    args: {},
+    ...overrides,
+  };
+}
+
+export function makeToolExecuteAfterOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    output: "tool result",
+    title: "tool execution",
+    metadata: {},
+    ...overrides,
+  };
+}
+
+export function makeExperimentalChatMessagesTransformOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    messages: [
+      {
+        info: {
+          role: "user",
+          agent: "test-agent",
+        },
+        parts: [
+          {
+            type: "text",
+            text: "test message",
+          },
+        ],
+      },
+    ],
+    ...overrides,
+  };
+}
+
+export function makeExperimentalChatSystemTransformOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    title: "Test Title",
+    output: "test output",
+    ...overrides,
+  };
+}
+
+export function makeToolDefinitionOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makePermissionAskOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeCommandExecuteBeforeOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeShellEnvOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeExperimentalSessionCompactingOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}
+
+export function makeExperimentalTextCompleteOutput(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    ...overrides,
+  };
+}

package/src/test-utils/mock-plugin-context.test.ts

@@ -0,0 +1,32 @@
+import { describe, test, expect } from "bun:test";
+import { createMockPluginContext } from "./mock-plugin-context";
+import { createMockAgentConfig } from "./mock-agent-config";
+
+describe("createMockPluginContext", () => {
+  test("returns context with default directory", () => {
+    //#given
+    //#when
+    const ctx = createMockPluginContext();
+    //#then
+    expect(ctx.directory).toBe("/tmp/test-project");
+  });
+
+  test("respects overrides", () => {
+    //#given
+    const customDir = "/custom/dir";
+    //#when
+    const ctx = createMockPluginContext({ directory: customDir });
+    //#then
+    expect(ctx.directory).toBe(customDir);
+  });
+});
+
+describe("createMockAgentConfig", () => {
+  test("returns config with default model", () => {
+    //#given
+    //#when
+    const config = createMockAgentConfig();
+    //#then
+    expect(config.model).toBe("anthropic/claude-sonnet-4-6");
+  });
+});

package/src/test-utils/mock-plugin-context.ts

@@ -0,0 +1,21 @@
+import type { OpenCodeContext } from "../types/plugin";
+
+/**
+ * Create a minimal mock OpenCodeContext for unit testing.
+ * Provides sensible no-op defaults for all required fields.
+ */
+export function createMockPluginContext(overrides: Partial<OpenCodeContext> = {}): OpenCodeContext {
+  const mock = {
+    directory: "/tmp/test-project",
+    client: {
+      getProviders: async () => [],
+      getModels: async () => [],
+      getSession: async () => null,
+      listSessions: async () => [],
+      createSession: async () => ({ id: "ses_test", title: "Test Session" }),
+      sendMessage: async () => ({}),
+    },
+    ...overrides,
+  } as OpenCodeContext;
+  return mock;
+}

package/src/test-utils/mock-sdk-client.ts

@@ -0,0 +1,52 @@
+import { mock } from "bun:test";
+
+/**
+ * Create a minimal mock SDK client for unit testing.
+ * Provides mock methods for all client operations.
+ */
+export function createMockSdkClient(overrides: Record<string, unknown> = {}) {
+  const base = {
+    getProviders: mock(async () => []),
+    getModels: mock(async () => []),
+    getSession: mock(async () => null),
+    listSessions: mock(async () => []),
+    createSession: mock(async () => ({
+      id: "ses_test",
+      title: "Test Session",
+    })),
+    sendMessage: mock(async () => ({})),
+    session: {
+      create: mock(async () => ({
+        data: { id: "sync-session-123" },
+        error: undefined,
+      })),
+      promptAsync: mock(async () => ({
+        data: {},
+        error: undefined,
+      })),
+      status: mock(async () => ({
+        data: {
+          "sync-session-123": { type: "idle" },
+        },
+      })),
+      messages: mock(async () => ({
+        data: [
+          { role: "user", content: "test prompt" },
+          { role: "assistant", content: "task result here" },
+        ],
+      })),
+      delete: mock(async () => ({})),
+    },
+  };
+
+  const overrideSession = (overrides as { session?: Record<string, unknown> }).session ?? {};
+
+  return {
+    ...base,
+    ...overrides,
+    session: {
+      ...base.session,
+      ...overrideSession,
+    },
+  };
+}

package/src/test-utils/mock-tool-context.ts

@@ -0,0 +1,24 @@
+import { mock } from "bun:test";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { createMockSdkClient } from "./mock-sdk-client";
+
+/**
+ * Create a minimal mock tool context for unit testing.
+ * Provides sensible defaults for all required context fields.
+ */
+export function createMockToolContext(
+  overrides: Partial<Parameters<ToolDefinition["execute"]>[1]> = {},
+): Parameters<ToolDefinition["execute"]>[1] {
+  return {
+    sessionID: "ses_test",
+    messageID: "msg_test",
+    agent: "test-agent",
+    directory: "/tmp/test-project",
+    worktree: "/tmp/test-project",
+    abort: new AbortController().signal,
+    metadata: mock(() => {}),
+    ask: mock(async () => {}),
+    client: createMockSdkClient(),
+    ...overrides,
+  } as unknown as Parameters<ToolDefinition["execute"]>[1];
+}

package/src/tools/ast-grep/index.ts

@@ -0,0 +1,4 @@
+export { astGrepSearchPlugin } from "./search/plugin";
+export { astGrepReplacePlugin } from "./replace/plugin";
+export { createAstGrepSearchTool, executeAstGrepSearch } from "./search/handler";
+export { createAstGrepReplaceTool, executeAstGrepReplace } from "./replace/handler";

package/src/tools/ast-grep/replace/handler.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, mock } from "bun:test";
+import { createAstGrepReplaceTool } from "./handler";
+import { createMockToolContext } from "../../../test-utils";
+
+describe("astGrepReplaceTool", () => {
+  describe("#given a dry-run replacement", () => {
+    describe("#when dryRun is not explicitly set to false", () => {
+      it("#then does not include --update-all and prefixes output with [DRY RUN]", async () => {
+        let capturedCommand: string[] = [];
+        const runner = mock(async (command: string[], _cwd: string) => {
+          capturedCommand = command;
+          return {
+            exitCode: 0,
+            stdout: "would replace in src/main.ts",
+            stderr: "",
+          };
+        });
+        const tool = createAstGrepReplaceTool(runner);
+        const ctx = createMockToolContext({ directory: "/repo" });
+
+        const result = await tool.execute(
+          {
+            pattern: "console.log($MSG)",
+            rewrite: "logger.info($MSG)",
+            lang: "typescript",
+          },
+          ctx,
+        );
+
+        expect(capturedCommand).not.toContain("--update-all");
+        expect(result).toBe("[DRY RUN]\nwould replace in src/main.ts");
+      });
+    });
+  });
+
+  describe("#given a non-dry-run replacement", () => {
+    describe("#when dryRun is false", () => {
+      it("#then includes --update-all and returns raw output", async () => {
+        let capturedCommand: string[] = [];
+        const runner = mock(async (command: string[], _cwd: string) => {
+          capturedCommand = command;
+          return {
+            exitCode: 0,
+            stdout: "updated src/main.ts",
+            stderr: "",
+          };
+        });
+        const tool = createAstGrepReplaceTool(runner);
+        const ctx = createMockToolContext({ directory: "/repo" });
+
+        const result = await tool.execute(
+          {
+            pattern: "console.log($MSG)",
+            rewrite: "logger.info($MSG)",
+            lang: "typescript",
+            dryRun: false,
+          },
+          ctx,
+        );
+
+        expect(capturedCommand).toContain("--update-all");
+        expect(capturedCommand).toContain("--rewrite");
+        expect(capturedCommand).toContain("logger.info($MSG)");
+        expect(result).toBe("updated src/main.ts");
+      });
+    });
+  });
+
+  describe("#given a pattern that matches nothing", () => {
+    describe("#when runner returns empty stdout", () => {
+      it("#then returns no matches to replace message", async () => {
+        const runner = mock(async (_command: string[], _cwd: string) => ({
+          exitCode: 0,
+          stdout: "",
+          stderr: "",
+        }));
+        const tool = createAstGrepReplaceTool(runner);
+        const ctx = createMockToolContext({ directory: "/repo" });
+
+        const result = await tool.execute(
+          {
+            pattern: "nonExistent($$$)",
+            rewrite: "replacement($$$)",
+            lang: "typescript",
+          },
+          ctx,
+        );
+
+        expect(result).toBe("No matches found to replace");
+      });
+    });
+  });
+});

package/src/tools/ast-grep/replace/handler.ts

@@ -0,0 +1,89 @@
+import { resolve } from "node:path";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { buildTool } from "../../tool-builder";
+import { log } from "../../../shared/logger";
+import type { CommandRunner } from "../search/handler";
+import { runCommand } from "../search/handler";
+import type { AstGrepReplaceArgs, AstGrepReplaceOutput } from "./types";
+import { astGrepReplaceArgsSchema } from "./types";
+
+const SG_NOT_FOUND_MESSAGE =
+  "Error: ast-grep binary 'sg' not found on PATH. Install ast-grep and retry.";
+
+function buildReplaceCommand(args: AstGrepReplaceArgs, workingDirectory: string): string[] {
+  const command = [
+    "sg",
+    "scan",
+    "--pattern",
+    args.pattern,
+    "--rewrite",
+    args.rewrite,
+    "--lang",
+    args.lang,
+  ];
+
+  for (const globPattern of args.globs ?? []) {
+    command.push("--glob", globPattern);
+  }
+
+  if (args.dryRun === false) {
+    command.push("--update-all");
+  }
+
+  const targetPaths = args.paths?.length ? args.paths : ["."];
+  for (const targetPath of targetPaths) {
+    command.push(resolve(workingDirectory, targetPath));
+  }
+
+  return command;
+}
+
+export async function executeAstGrepReplace(
+  args: AstGrepReplaceArgs,
+  context: { directory: string },
+  runner: CommandRunner = runCommand,
+): Promise<AstGrepReplaceOutput> {
+  const command = buildReplaceCommand(args, context.directory);
+  log("ast_grep_replace executing", {
+    command,
+    directory: context.directory,
+    dryRun: args.dryRun !== false,
+  });
+
+  try {
+    const result = await runner(command, context.directory);
+    if (result.exitCode !== 0) {
+      const errorOutput = result.stderr.trim() || result.stdout.trim();
+      if (errorOutput.includes("ENOENT") || errorOutput.includes("not found")) {
+        return SG_NOT_FOUND_MESSAGE;
+      }
+      return `Error: ${errorOutput || "ast-grep command failed"}`;
+    }
+
+    const output = result.stdout.trim();
+    if (output.length > 0) {
+      return args.dryRun === false ? output : `[DRY RUN]\n${output}`;
+    }
+
+    return "No matches found to replace";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log("ast_grep_replace failed", { message });
+    if (message.includes("ENOENT") || message.includes("not found")) {
+      return SG_NOT_FOUND_MESSAGE;
+    }
+    return `Error: ${message}`;
+  }
+}
+
+export function createAstGrepReplaceTool(runner?: CommandRunner): ToolDefinition {
+  return buildTool({
+    description:
+      "Replace code patterns across filesystem with AST-aware rewriting. " +
+      "Dry-run by default. Use meta-variables in rewrite to preserve matched content. " +
+      "Example: pattern='console.log($MSG)' rewrite='logger.info($MSG)'",
+    args: astGrepReplaceArgsSchema as unknown as ToolDefinition["args"],
+    execute: async (toolArgs, toolContext) =>
+      executeAstGrepReplace(toolArgs as AstGrepReplaceArgs, toolContext, runner),
+  });
+}

package/src/tools/ast-grep/replace/plugin.ts

@@ -0,0 +1,10 @@
+import { definePlugin } from "../../../plugin-api";
+import { createAstGrepReplaceTool } from "./handler";
+
+export const astGrepReplacePlugin = definePlugin({
+  name: "ast-grep-replace",
+  version: "0.1.0",
+  tools: {
+    ast_grep_replace: createAstGrepReplaceTool(),
+  },
+});

package/src/tools/ast-grep/replace/types.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { AST_GREP_CLI_LANGUAGES } from "../search/types";
+
+export const astGrepReplaceArgsSchema = {
+  pattern: z.string().describe("AST pattern to match"),
+  rewrite: z.string().describe("Replacement pattern (can use $VAR from pattern)"),
+  lang: z.enum(AST_GREP_CLI_LANGUAGES).describe("Target language"),
+  paths: z.array(z.string()).optional().describe("Paths to search"),
+  globs: z.array(z.string()).optional().describe("Include/exclude globs"),
+  dryRun: z.boolean().optional().describe("Preview changes without applying (default: true)"),
+};
+
+export type AstGrepReplaceArgs = z.infer<z.ZodObject<typeof astGrepReplaceArgsSchema>>;
+export type AstGrepReplaceOutput = string;