automaker/apps/server/tests/unit/lib/prompt-builder.test.ts

import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import * as utils from "@automaker/utils";
import * as fs from "fs/promises";

// Mock fs module for the image-handler's readFile calls
vi.mock("fs/promises");

describe("prompt-builder.ts", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    // Setup default mock for fs.readFile to return a valid image buffer
    vi.mocked(fs.readFile).mockResolvedValue(Buffer.from("fake-image-data"));
  });

  afterEach(() => {
    vi.restoreAllMocks();
  });

  describe("buildPromptWithImages", () => {
    it("should return plain text when no images provided", async () => {
      const result = await utils.buildPromptWithImages("Hello world");

      expect(result).toEqual({
        content: "Hello world",
        hasImages: false,
      });
    });

    it("should return plain text when imagePaths is empty array", async () => {
      const result = await utils.buildPromptWithImages("Hello world", []);

      expect(result).toEqual({
        content: "Hello world",
        hasImages: false,
      });
    });

    it("should build content blocks with single image", async () => {
      const result = await utils.buildPromptWithImages("Describe this image", [
        "/test.png",
      ]);

      expect(result.hasImages).toBe(true);
      expect(Array.isArray(result.content)).toBe(true);
      const content = result.content as Array<{ type: string; text?: string }>;
      expect(content).toHaveLength(2);
      expect(content[0]).toEqual({ type: "text", text: "Describe this image" });
      expect(content[1].type).toBe("image");
    });

    it("should build content blocks with multiple images", async () => {
      const result = await utils.buildPromptWithImages("Analyze these", [
        "/a.png",
        "/b.jpg",
      ]);

      expect(result.hasImages).toBe(true);
      const content = result.content as Array<{ type: string }>;
      expect(content).toHaveLength(3); // 1 text + 2 images
      expect(content[0].type).toBe("text");
      expect(content[1].type).toBe("image");
      expect(content[2].type).toBe("image");
    });

    it("should include image paths in text when requested", async () => {
      const result = await utils.buildPromptWithImages(
        "Base prompt",
        ["/test.png"],
        undefined,
        true
      );

      const content = result.content as Array<{ type: string; text?: string }>;
      expect(content[0].text).toContain("Base prompt");
      expect(content[0].text).toContain("/test.png");
    });

    it("should not include image paths by default", async () => {
      const result = await utils.buildPromptWithImages("Base prompt", ["/test.png"]);

      const content = result.content as Array<{ type: string; text?: string }>;
      expect(content[0].text).toBe("Base prompt");
      expect(content[0].text).not.toContain("Attached");
    });

    it("should handle empty text content", async () => {
      const result = await utils.buildPromptWithImages("", ["/test.png"]);

      expect(result.hasImages).toBe(true);
      // When text is empty/whitespace, should only have image blocks
      const content = result.content as Array<{ type: string }>;
      expect(content.every((block) => block.type === "image")).toBe(true);
    });

    it("should trim text content before checking if empty", async () => {
      const result = await utils.buildPromptWithImages("   ", ["/test.png"]);

      const content = result.content as Array<{ type: string }>;
      // Whitespace-only text should be excluded
      expect(content.every((block) => block.type === "image")).toBe(true);
    });

    it("should return text when only one block and it's text", async () => {
      // Make readFile reject to simulate image load failure
      vi.mocked(fs.readFile).mockRejectedValue(new Error("File not found"));

      const result = await utils.buildPromptWithImages("Just text", ["/missing.png"]);

      // If no images are successfully loaded, should return just the text
      expect(result.content).toBe("Just text");
      expect(result.hasImages).toBe(true); // Still true because images were requested
    });

    it("should pass workDir for path resolution", async () => {
      // The function should use workDir to resolve relative paths
      const result = await utils.buildPromptWithImages(
        "Test",
        ["relative.png"],
        "/work/dir"
      );

      // Verify it tried to read the file (with resolved path including workDir)
      expect(fs.readFile).toHaveBeenCalled();
      // The path should be resolved using workDir
      const readCall = vi.mocked(fs.readFile).mock.calls[0][0];
      expect(readCall).toContain("relative.png");
    });
  });
});