automaker/libs/utils/tests/prompt-builder.test.ts

import { describe, it, expect, beforeEach, afterEach } from "vitest";
import fs from "fs/promises";
import path from "path";
import os from "os";
import { buildPromptWithImages } from "../src/prompt-builder";

describe("prompt-builder.ts", () => {
  let tempDir: string;

  beforeEach(async () => {
    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "prompt-builder-test-"));
  });

  afterEach(async () => {
    try {
      await fs.rm(tempDir, { recursive: true, force: true });
    } catch (error) {
      // Ignore cleanup errors
    }
  });

  describe("buildPromptWithImages - no images", () => {
    it("should return plain text when no images provided", async () => {
      const basePrompt = "Hello, world!";

      const result = await buildPromptWithImages(basePrompt);

      expect(result.content).toBe("Hello, world!");
      expect(result.hasImages).toBe(false);
    });

    it("should return plain text when empty image array provided", async () => {
      const basePrompt = "Test prompt";

      const result = await buildPromptWithImages(basePrompt, []);

      expect(result.content).toBe("Test prompt");
      expect(result.hasImages).toBe(false);
    });

    it("should handle multiline prompts", async () => {
      const basePrompt = "Line 1\nLine 2\nLine 3";

      const result = await buildPromptWithImages(basePrompt);

      expect(result.content).toBe("Line 1\nLine 2\nLine 3");
    });
  });

  describe("buildPromptWithImages - with images", () => {
    it("should build content blocks with single image", async () => {
      const imagePath = path.join(tempDir, "test.png");
      await fs.writeFile(imagePath, Buffer.from("image data"));

      const result = await buildPromptWithImages(
        "Check this image",
        [imagePath]
      );

      expect(result.hasImages).toBe(true);
      expect(Array.isArray(result.content)).toBe(true);

      const blocks = result.content as Array<{
        type: string;
        text?: string;
        source?: object;
      }>;
      expect(blocks).toHaveLength(2);
      expect(blocks[0]).toMatchObject({
        type: "text",
        text: "Check this image",
      });
      expect(blocks[1]).toMatchObject({
        type: "image",
      });
    });

    it("should build content blocks with multiple images", async () => {
      const image1 = path.join(tempDir, "img1.jpg");
      const image2 = path.join(tempDir, "img2.png");

      await fs.writeFile(image1, Buffer.from("jpg data"));
      await fs.writeFile(image2, Buffer.from("png data"));

      const result = await buildPromptWithImages("Two images", [
        image1,
        image2,
      ]);

      expect(result.hasImages).toBe(true);

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

    it("should resolve relative paths with workDir", async () => {
      const imagePath = "test.png";
      const fullPath = path.join(tempDir, imagePath);
      await fs.writeFile(fullPath, Buffer.from("data"));

      const result = await buildPromptWithImages(
        "Test",
        [imagePath],
        tempDir
      );

      expect(result.hasImages).toBe(true);
      expect(Array.isArray(result.content)).toBe(true);
    });

    it("should handle absolute paths without workDir", async () => {
      const imagePath = path.join(tempDir, "absolute.png");
      await fs.writeFile(imagePath, Buffer.from("data"));

      const result = await buildPromptWithImages("Test", [imagePath]);

      expect(result.hasImages).toBe(true);
    });
  });

  describe("buildPromptWithImages - includeImagePaths option", () => {
    it("should not include image paths by default", async () => {
      const imagePath = path.join(tempDir, "test.png");
      await fs.writeFile(imagePath, Buffer.from("data"));

      const result = await buildPromptWithImages("Prompt", [imagePath]);

      const blocks = result.content as Array<{
        type: string;
        text?: string;
      }>;
      const textBlock = blocks.find((b) => b.type === "text");

      expect(textBlock?.text).not.toContain("Attached images:");
      expect(textBlock?.text).toBe("Prompt");
    });

    it("should include image paths when requested", async () => {
      const imagePath = path.join(tempDir, "test.png");
      await fs.writeFile(imagePath, Buffer.from("data"));

      const result = await buildPromptWithImages(
        "Prompt",
        [imagePath],
        undefined,
        true
      );

      const blocks = result.content as Array<{
        type: string;
        text?: string;
      }>;
      const textBlock = blocks.find((b) => b.type === "text");

      expect(textBlock?.text).toContain("Prompt");
      expect(textBlock?.text).toContain("Attached images:");
      expect(textBlock?.text).toContain(imagePath);
    });

    it("should format multiple image paths when included", async () => {
      const img1 = path.join(tempDir, "img1.png");
      const img2 = path.join(tempDir, "img2.jpg");

      await fs.writeFile(img1, Buffer.from("data1"));
      await fs.writeFile(img2, Buffer.from("data2"));

      const result = await buildPromptWithImages(
        "Test",
        [img1, img2],
        undefined,
        true
      );

      const blocks = result.content as Array<{
        type: string;
        text?: string;
      }>;
      const textBlock = blocks.find((b) => b.type === "text");

      expect(textBlock?.text).toContain("Attached images:");
      expect(textBlock?.text).toContain(img1);
      expect(textBlock?.text).toContain(img2);
    });
  });

  describe("buildPromptWithImages - edge cases", () => {
    it("should handle empty prompt with images", async () => {
      const imagePath = path.join(tempDir, "test.png");
      await fs.writeFile(imagePath, Buffer.from("data"));

      const result = await buildPromptWithImages("", [imagePath]);

      expect(result.hasImages).toBe(true);

      const blocks = result.content as Array<{
        type: string;
        text?: string;
        source?: object;
      }>;
      // Should only have image block, no text block for empty string
      expect(blocks.length).toBeGreaterThan(0);
      expect(blocks.some((b) => b.type === "image")).toBe(true);
    });

    it("should handle whitespace-only prompt with images", async () => {
      const imagePath = path.join(tempDir, "test.png");
      await fs.writeFile(imagePath, Buffer.from("data"));

      const result = await buildPromptWithImages("   ", [imagePath]);

      expect(result.hasImages).toBe(true);

      const blocks = result.content as Array<{
        type: string;
        text?: string;
        source?: object;
      }>;
      // Whitespace-only is trimmed, so no text block should be added
      expect(blocks.every((b) => b.type !== "text")).toBe(true);
    });

    it("should skip failed image loads", async () => {
      const validImage = path.join(tempDir, "valid.png");
      const invalidImage = path.join(tempDir, "nonexistent.png");

      await fs.writeFile(validImage, Buffer.from("data"));

      const result = await buildPromptWithImages("Test", [
        validImage,
        invalidImage,
      ]);

      expect(result.hasImages).toBe(true);

      const blocks = result.content as Array<{
        type: string;
        text?: string;
        source?: object;
      }>;
      const imageBlocks = blocks.filter((b) => b.type === "image");

      // Only valid image should be included
      expect(imageBlocks).toHaveLength(1);
    });

    it("should handle mixed case in includeImagePaths parameter", async () => {
      const imagePath = path.join(tempDir, "test.png");
      await fs.writeFile(imagePath, Buffer.from("data"));

      const resultFalse = await buildPromptWithImages(
        "Test",
        [imagePath],
        undefined,
        false
      );
      const resultTrue = await buildPromptWithImages(
        "Test",
        [imagePath],
        undefined,
        true
      );

      const blocksFalse = resultFalse.content as Array<{
        type: string;
        text?: string;
      }>;
      const blocksTrue = resultTrue.content as Array<{
        type: string;
        text?: string;
      }>;

      expect(blocksFalse[0].text).not.toContain("Attached images:");
      expect(blocksTrue[0].text).toContain("Attached images:");
    });
  });

  describe("buildPromptWithImages - content format", () => {
    it("should return string when only text and includeImagePaths false", async () => {
      const result = await buildPromptWithImages("Just text", undefined);

      expect(typeof result.content).toBe("string");
    });

    it("should return array when has images", async () => {
      const imagePath = path.join(tempDir, "test.png");
      await fs.writeFile(imagePath, Buffer.from("data"));

      const result = await buildPromptWithImages("Text", [imagePath]);

      expect(Array.isArray(result.content)).toBe(true);
    });

    it("should preserve prompt formatting", async () => {
      const basePrompt = "Line 1\n\nLine 2\n  Indented line";
      const imagePath = path.join(tempDir, "test.png");
      await fs.writeFile(imagePath, Buffer.from("data"));

      const result = await buildPromptWithImages(basePrompt, [imagePath]);

      const blocks = result.content as Array<{
        type: string;
        text?: string;
      }>;
      const textBlock = blocks.find((b) => b.type === "text");

      expect(textBlock?.text).toBe(basePrompt);
    });
  });
});