goatcode-sh 0.0.1 → 0.1.2

package/src/tools/hashline-edit/index.ts

@@ -0,0 +1,5 @@
+export { hashlineEditPlugin, hashlineEditTool } from "./plugin";
+export { executeHashlineEdit } from "./handler";
+export { computeLineHash, formatHashLine } from "./hash-computation";
+export { applyHashlineEdits, applyEditOperations, planEditOperations } from "./edit-operations";
+export type { HashlineEdit, HashlineEditToolArgs, EditOperation, ParsedHashline } from "./types";

package/src/tools/hashline-edit/plugin.ts

@@ -0,0 +1,28 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { definePlugin } from "../../plugin-api";
+import { buildTool } from "../tool-builder";
+import { executeHashlineEdit } from "./handler";
+import { hashlineEditArgsShape, type HashlineEditToolArgs } from "./types";
+
+const HASHLINE_EDIT_DESCRIPTION = `Edit file lines via hash-anchored LINE#ID references.
+
+Each edit includes oldString in LINE#ID|content format plus a hash field. The tool recomputes
+the current hash at the matched content location before applying replacements. If hashes differ,
+it rejects the request with a stale content error to prevent corrupting updated files.`;
+
+export const hashlineEditTool: ToolDefinition = buildTool<
+  typeof hashlineEditArgsShape,
+  HashlineEditToolArgs
+>({
+  description: HASHLINE_EDIT_DESCRIPTION,
+  args: hashlineEditArgsShape,
+  execute: executeHashlineEdit,
+});
+
+export const hashlineEditPlugin = definePlugin({
+  name: "hashline-edit",
+  version: "0.1.0",
+  tools: {
+    hashline_edit: hashlineEditTool,
+  },
+});

package/src/tools/hashline-edit/types.ts

@@ -0,0 +1,42 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import type { ToolDefinition } from "@opencode-ai/plugin";
+
+const HASH_CHARS = "ZPMQVRWSNKTXJBYH";
+
+const HASH_PATTERN = new RegExp(`^[${HASH_CHARS}]{2}$`);
+const HASHLINE_OLD_STRING_PATTERN = new RegExp(`^[0-9]+#[${HASH_CHARS}]{2}\\|.*$`);
+
+const hashlineEditSchema = tool.schema.object({
+  oldString: tool.schema
+    .string()
+    .regex(HASHLINE_OLD_STRING_PATTERN, 'oldString must use "LINE#ID|content" format'),
+  newString: tool.schema.string().describe("Replacement text; supports embedded newlines"),
+  hash: tool.schema.string().regex(HASH_PATTERN, "hash must be two hashline characters"),
+});
+
+export const hashlineEditArgsShape: ToolDefinition["args"] = {
+  filePath: tool.schema.string().describe("Absolute path to the target file"),
+  edits: tool.schema.array(hashlineEditSchema).describe("Edits anchored by LINE#ID hashes"),
+};
+
+export interface HashlineEdit {
+  oldString: string;
+  newString: string;
+  hash: string;
+}
+export type HashlineEditToolArgs = {
+  filePath: string;
+  edits: HashlineEdit[];
+};
+
+export interface ParsedHashline {
+  lineNumber: number;
+  hash: string;
+  content: string;
+}
+
+export interface EditOperation {
+  editIndex: number;
+  lineIndex: number;
+  newLines: string[];
+}

package/src/tools/index.ts

@@ -0,0 +1,4 @@
+export { buildToolHook } from "./bridge";
+export { buildTool } from "./tool-builder";
+export { adaptToolsToRegistry, mergeToolRegistries } from "./tool-registry-adapter";
+export * from "./shared/constants";

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

@@ -0,0 +1,189 @@
+import { describe, it, expect, mock } from "bun:test";
+import { createLookAtTool, extractLatestAssistantText } 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 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: "Extracted info from the file." },
+        ],
+        error: null,
+      })),
+      status: mock(async () => ({
+        data: { "child-session-id": { type: "idle" } },
+        error: null,
+      })),
+      ...sessionOverrides,
+    },
+  };
+}
+
+function makeContext(client: ReturnType<typeof makeClient>): ToolContext {
+  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,
+  } as unknown as ToolContext;
+}
+
+describe("lookAtTool", () => {
+  describe("#given both file_path and image_data provided", () => {
+    describe("#when execute is called with both", () => {
+      it("#then returns XOR validation error", async () => {
+        const client = makeClient();
+        const ctx = makeContext(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 neither file_path nor image_data", () => {
+    describe("#when execute is called with only a goal", () => {
+      it("#then returns must-provide error", async () => {
+        const client = makeClient();
+        const ctx = makeContext(client);
+        const tool = createLookAtTool(noopPoller);
+
+        const result = await tool.execute({ goal: "describe something" }, ctx);
+
+        expect(result).toContain("Error: Must provide either");
+        expect(client.session.create).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given missing goal parameter", () => {
+    describe("#when execute is called without goal", () => {
+      it("#then returns missing goal error", async () => {
+        const client = makeClient();
+        const ctx = makeContext(client);
+        const tool = createLookAtTool(noopPoller);
+
+        const result = await tool.execute({ file_path: "/tmp/some-file.txt" }, ctx);
+
+        expect(result).toContain("Error: Missing required parameter 'goal'");
+        expect(client.session.create).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given a text file path", () => {
+    describe("#when the file exists and Inspector agent responds", () => {
+      it("#then returns the assistant analysis result", async () => {
+        const client = makeClient();
+        const ctx = makeContext(client);
+        const tool = createLookAtTool(noopPoller);
+
+        await Bun.write("/tmp/look-at-handler-test.txt", "Some test file content.");
+
+        const result = await tool.execute(
+          { file_path: "/tmp/look-at-handler-test.txt", goal: "summarize content" },
+          ctx,
+        );
+
+        expect(result).toBe("Extracted info from the file.");
+        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 returns file not found error", async () => {
+        const client = makeClient();
+        const ctx = makeContext(client);
+        const tool = createLookAtTool(noopPoller);
+
+        const result = await tool.execute(
+          { file_path: "/tmp/nonexistent-handler-test-xyz.txt", goal: "find data" },
+          ctx,
+        );
+
+        expect(result).toContain("Error: File not found");
+        expect(client.session.create).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("#given the poller times out", () => {
+    describe("#when the Inspector agent never becomes idle", () => {
+      it("#then returns a timeout error", async () => {
+        const client = makeClient();
+        const ctx = makeContext(client);
+
+        const timeoutPoller = async () => {
+          throw new Error("Polling timed out");
+        };
+        const tool = createLookAtTool(timeoutPoller);
+
+        await Bun.write("/tmp/look-at-timeout-test.txt", "content");
+
+        const result = await tool.execute(
+          { file_path: "/tmp/look-at-timeout-test.txt", goal: "find data" },
+          ctx,
+        );
+
+        expect(result).toContain("Error: Timed out waiting for Inspector agent response");
+      });
+    });
+  });
+});
+
+describe("extractLatestAssistantText", () => {
+  describe("#given messages with an assistant reply", () => {
+    describe("#when called", () => {
+      it("#then returns the last assistant message content", () => {
+        const messages = [
+          { role: "user", content: "hello" },
+          { role: "assistant", content: "first reply" },
+          { role: "user", content: "follow up" },
+          { role: "assistant", content: "second reply" },
+        ];
+        expect(extractLatestAssistantText(messages)).toBe("second reply");
+      });
+    });
+  });
+
+  describe("#given messages with no assistant reply", () => {
+    describe("#when called", () => {
+      it("#then returns null", () => {
+        const messages = [{ role: "user", content: "hello" }];
+        expect(extractLatestAssistantText(messages)).toBeNull();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,232 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin";
+import { log } from "../../shared/logger";
+import { getClientFromToolContext } from "../lsp/client";
+import { pollUntilStable, type PollSnapshot } from "../../runtime";
+import { LOOK_AT_DESCRIPTION, LOOK_AT_AGENT_NAME } from "./types";
+
+export type Poller = (fetchSnapshot: () => Promise<PollSnapshot>) => Promise<PollSnapshot>;
+
+type SessionMessage = {
+  role?: string;
+  content?: string;
+};
+
+type SessionStatusRecord = Record<string, { type?: string }>;
+
+const BINARY_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".bmp",
+  ".tiff",
+  ".tif",
+  ".pdf",
+  ".ico",
+  ".svg",
+]);
+
+function isBinaryPath(filePath: string): boolean {
+  const lower = filePath.toLowerCase();
+  for (const ext of BINARY_EXTENSIONS) {
+    if (lower.endsWith(ext)) return true;
+  }
+  return false;
+}
+
+function buildPrompt(goal: string, isImage: boolean): string {
+  const subject = isImage ? "image" : "file";
+  return `Analyze this ${subject} and extract the requested information.\n\nGoal: ${goal}\n\nProvide ONLY the extracted information that matches the goal.\nBe thorough on what was requested, concise on everything else.\nIf the requested information is not found, clearly state what is missing.`;
+}
+
+export function extractLatestAssistantText(messages: unknown[]): string | null {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i];
+    if (typeof msg !== "object" || msg === null) continue;
+    const record = msg as Record<string, unknown>;
+    if (record.role !== "assistant") continue;
+    if (typeof record.content === "string" && record.content.length > 0) return record.content;
+  }
+  return null;
+}
+
+function isSessionMessage(value: unknown): value is SessionMessage {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value as Record<string, unknown>;
+  return (
+    (record.role === undefined || typeof record.role === "string") &&
+    (record.content === undefined || typeof record.content === "string")
+  );
+}
+
+function toSessionMessages(value: unknown): SessionMessage[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter(isSessionMessage);
+}
+
+function isSessionStatusRecord(value: unknown): value is SessionStatusRecord {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  for (const status of Object.values(value as Record<string, unknown>)) {
+    if (typeof status !== "object" || status === null || Array.isArray(status)) {
+      return false;
+    }
+    const type = (status as Record<string, unknown>).type;
+    if (type !== undefined && typeof type !== "string") {
+      return false;
+    }
+  }
+  return true;
+}
+
+async function readFileAsBase64(filePath: string): Promise<string> {
+  const file = Bun.file(filePath);
+  const buffer = await file.arrayBuffer();
+  return Buffer.from(buffer).toString("base64");
+}
+
+function inferMimeType(filePath: string): string {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".pdf")) return "application/pdf";
+  if (lower.endsWith(".png")) return "image/png";
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".gif")) return "image/gif";
+  if (lower.endsWith(".webp")) return "image/webp";
+  if (lower.endsWith(".bmp")) return "image/bmp";
+  if (lower.endsWith(".tiff") || lower.endsWith(".tif")) return "image/tiff";
+  if (lower.endsWith(".ico")) return "image/x-icon";
+  if (lower.endsWith(".svg")) return "image/svg+xml";
+  return "application/octet-stream";
+}
+
+export function createLookAtTool(poller: Poller = pollUntilStable): ToolDefinition {
+  return tool({
+    description: LOOK_AT_DESCRIPTION,
+    args: {
+      file_path: tool.schema.string().optional().describe("Absolute path to the file to analyze"),
+      goal: tool.schema.string().describe("What specific information to extract from the file"),
+      image_data: tool.schema
+        .string()
+        .optional()
+        .describe("Base64 encoded image data (for clipboard/pasted images)"),
+    },
+    execute: async (args, toolContext) => {
+      const filePath = args.file_path;
+      const imageData = args.image_data;
+      const goal = args.goal;
+
+      if (!filePath && !imageData) return "Error: Must provide either 'file_path' or 'image_data'.";
+      if (filePath && imageData)
+        return "Error: Provide only one of 'file_path' or 'image_data', not both.";
+      if (!goal) return "Error: Missing required parameter 'goal'.";
+
+      const client = getClientFromToolContext(toolContext);
+      log(`[look_at] Analyzing ${imageData ? "clipboard/pasted image" : filePath}, goal: ${goal}`);
+
+      let promptText: string;
+      let filePart: { type: "file"; mime: string; url: string; filename: string } | null = null;
+
+      if (imageData) {
+        const mimeMatch = imageData.match(/^data:([^;]+);base64,/);
+        const mime = mimeMatch ? mimeMatch[1] : "image/png";
+        const base64 = mimeMatch ? imageData.slice(mimeMatch[0].length) : imageData;
+        filePart = {
+          type: "file",
+          mime,
+          url: `data:${mime};base64,${base64}`,
+          filename: `clipboard-image.${mime.split("/")[1] ?? "png"}`,
+        };
+        promptText = buildPrompt(goal, true);
+      } else if (filePath) {
+        const file = Bun.file(filePath);
+        if (!(await file.exists())) {
+          log(`[look_at] File not found: ${filePath}`);
+          return `Error: File not found: ${filePath}`;
+        }
+        if (isBinaryPath(filePath)) {
+          const base64 = await readFileAsBase64(filePath);
+          const mime = inferMimeType(filePath);
+          filePart = {
+            type: "file",
+            mime,
+            url: `data:${mime};base64,${base64}`,
+            filename: filePath.split("/").pop() ?? "file",
+          };
+          promptText = buildPrompt(goal, mime.startsWith("image/"));
+        } else {
+          promptText = `${buildPrompt(goal, false)}\n\nFile contents:\n\`\`\`\n${await file.text()}\n\`\`\``;
+        }
+      } else {
+        return "Error: Must provide either 'file_path' or 'image_data'.";
+      }
+
+      const createResult = await client.session.create({
+        body: { parentID: toolContext.sessionID, title: `look_at: ${goal.substring(0, 50)}` },
+        query: { directory: toolContext.directory },
+      });
+
+      if (createResult.error) {
+        log(`[look_at] Session create error:`, createResult.error);
+        return `Error: Failed to create session: ${createResult.error}`;
+      }
+
+      const sessionId = createResult.data.id;
+      log(`[look_at] Created session: ${sessionId}`);
+
+      const parts: Array<
+        | { type: "text"; text: string }
+        | { type: "file"; mime: string; url: string; filename: string }
+      > = [{ type: "text", text: promptText }];
+      if (filePart) parts.push(filePart);
+
+      try {
+        await client.session.promptAsync({
+          path: { id: sessionId },
+          body: { agent: LOOK_AT_AGENT_NAME, parts },
+        });
+      } catch (promptError) {
+        log(`[look_at] Prompt error:`, promptError);
+        const msg = promptError instanceof Error ? promptError.message : String(promptError);
+        return `Error: Failed to send prompt to Inspector agent: ${msg}`;
+      }
+
+      try {
+        await poller(async () => {
+          const [messagesResult, statusResult] = await Promise.all([
+            client.session.messages({ path: { id: sessionId } }),
+            client.session.status({ query: { directory: toolContext.directory } }),
+          ]);
+          const messages = toSessionMessages(messagesResult.data);
+          const statusData = isSessionStatusRecord(statusResult.data)
+            ? statusResult.data
+            : undefined;
+          return {
+            messageCount: messages.length,
+            isIdle: statusData?.[sessionId]?.type === "idle",
+          };
+        });
+      } catch (pollError) {
+        log(`[look_at] Polling error:`, pollError);
+        return "Error: Timed out waiting for Inspector agent response";
+      }
+
+      const messagesResult = await client.session.messages({ path: { id: sessionId } });
+      if (messagesResult.error) return `Error: Failed to get messages: ${messagesResult.error}`;
+
+      const messages = toSessionMessages(messagesResult.data);
+      const responseText = extractLatestAssistantText(messages);
+      if (!responseText) return "Error: No response from Inspector agent";
+
+      log(`[look_at] Got response, length: ${responseText.length}`);
+      return responseText;
+    },
+  });
+}
+
+export const lookAtTool: ToolDefinition = createLookAtTool();

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

@@ -0,0 +1,3 @@
+export { lookAtPlugin } from "./plugin";
+export { lookAtTool } from "./handler";
+export type { LookAtArgs } from "./types";