tower-studio 0.1.2 → 0.1.3

package/src/lib/__tests__/diff-parser.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect } from "vitest";
+import { parseDiffOutput } from "../diff-parser";
+
+// ── Helpers ──
+
+function makeNumstatLine(added: number | string, removed: number | string, filename: string) {
+  return `${added}\t${removed}\t${filename}`;
+}
+
+function makeUnifiedHeader(filename: string) {
+  return `diff --git a/${filename} b/${filename}\nindex abc1234..def5678 100644\n--- a/${filename}\n+++ b/${filename}`;
+}
+
+function makeHunk(contextLine: string, addedLine: string, removedLine: string) {
+  return `@@ -1,3 +1,3 @@\n ${contextLine}\n+${addedLine}\n-${removedLine}`;
+}
+
+// ── Tests ──
+
+describe("parseDiffOutput — empty inputs", () => {
+  it("returns empty result for empty numstat and unified diff", () => {
+    const result = parseDiffOutput("", "");
+    expect(result.files).toEqual([]);
+    expect(result.totalAdded).toBe(0);
+    expect(result.totalRemoved).toBe(0);
+  });
+
+  it("returns empty result for whitespace-only inputs", () => {
+    const result = parseDiffOutput("   \n\t  ", "  \n  ");
+    expect(result.files).toEqual([]);
+    expect(result.totalAdded).toBe(0);
+    expect(result.totalRemoved).toBe(0);
+  });
+});
+
+describe("parseDiffOutput — standard diff (adds and removes)", () => {
+  it("parses single file with adds and removes", () => {
+    const numstat = makeNumstatLine(10, 5, "src/app.ts");
+    const unified =
+      makeUnifiedHeader("src/app.ts") +
+      "\n" +
+      makeHunk("existing line", "new feature line", "old line") +
+      "\n";
+
+    const result = parseDiffOutput(numstat, unified);
+
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].filename).toBe("src/app.ts");
+    expect(result.files[0].added).toBe(10);
+    expect(result.files[0].removed).toBe(5);
+    expect(result.files[0].isBinary).toBe(false);
+    expect(result.files[0].patch).toContain("diff --git a/src/app.ts b/src/app.ts");
+    expect(result.totalAdded).toBe(10);
+    expect(result.totalRemoved).toBe(5);
+  });
+
+  it("parses multiple files and sums totals correctly", () => {
+    const numstat = [
+      makeNumstatLine(3, 1, "src/a.ts"),
+      makeNumstatLine(7, 2, "src/b.ts"),
+    ].join("\n");
+
+    const unified =
+      makeUnifiedHeader("src/a.ts") + "\n" + makeHunk("ctx", "add a", "rm a") + "\n" +
+      makeUnifiedHeader("src/b.ts") + "\n" + makeHunk("ctx", "add b", "rm b") + "\n";
+
+    const result = parseDiffOutput(numstat, unified);
+
+    expect(result.files).toHaveLength(2);
+    expect(result.totalAdded).toBe(10); // 3 + 7
+    expect(result.totalRemoved).toBe(3); // 1 + 2
+  });
+});
+
+describe("parseDiffOutput — added-only hunk", () => {
+  it("returns totalRemoved=0 when only lines added", () => {
+    const numstat = makeNumstatLine(5, 0, "src/new-file.ts");
+    const unified =
+      `diff --git a/src/new-file.ts b/src/new-file.ts\nnew file mode 100644\n--- /dev/null\n+++ b/src/new-file.ts\n` +
+      `@@ -0,0 +1,5 @@\n+line 1\n+line 2\n+line 3\n+line 4\n+line 5\n`;
+
+    const result = parseDiffOutput(numstat, unified);
+
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].added).toBe(5);
+    expect(result.files[0].removed).toBe(0);
+    expect(result.totalAdded).toBe(5);
+    expect(result.totalRemoved).toBe(0);
+  });
+});
+
+describe("parseDiffOutput — removed-only hunk", () => {
+  it("returns totalAdded=0 when only lines removed", () => {
+    const numstat = makeNumstatLine(0, 8, "src/old-file.ts");
+    const unified =
+      makeUnifiedHeader("src/old-file.ts") +
+      "\n@@ -1,8 +0,0 @@\n-line 1\n-line 2\n-line 3\n-line 4\n-line 5\n-line 6\n-line 7\n-line 8\n";
+
+    const result = parseDiffOutput(numstat, unified);
+
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].added).toBe(0);
+    expect(result.files[0].removed).toBe(8);
+    expect(result.totalAdded).toBe(0);
+    expect(result.totalRemoved).toBe(8);
+  });
+});
+
+describe("parseDiffOutput — binary files", () => {
+  it("marks binary file with isBinary=true and added=removed=0", () => {
+    const numstat = makeNumstatLine("-", "-", "assets/logo.png");
+    // Binary files typically don't produce unified diff output
+    const unified = "";
+
+    const result = parseDiffOutput(numstat, unified);
+
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].filename).toBe("assets/logo.png");
+    expect(result.files[0].isBinary).toBe(true);
+    expect(result.files[0].added).toBe(0);
+    expect(result.files[0].removed).toBe(0);
+  });
+
+  it("does not include binary file in totalAdded/totalRemoved", () => {
+    const numstat = [
+      makeNumstatLine("-", "-", "assets/logo.png"),
+      makeNumstatLine(3, 1, "src/code.ts"),
+    ].join("\n");
+    const unified = makeUnifiedHeader("src/code.ts") + "\n" + makeHunk("ctx", "add", "rm") + "\n";
+
+    const result = parseDiffOutput(numstat, unified);
+
+    expect(result.totalAdded).toBe(3);
+    expect(result.totalRemoved).toBe(1);
+  });
+});
+
+describe("parseDiffOutput — numstat with no matching unified diff segment", () => {
+  it("returns empty patch string when file not in unified diff", () => {
+    const numstat = makeNumstatLine(5, 2, "src/missing.ts");
+    const unified = ""; // No unified diff content
+
+    const result = parseDiffOutput(numstat, unified);
+
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].patch).toBe("");
+    expect(result.files[0].added).toBe(5);
+    expect(result.files[0].removed).toBe(2);
+  });
+});
+
+describe("parseDiffOutput — truncation at >500KB", () => {
+  it("truncates patch to 200 lines and appends truncation marker", () => {
+    const filename = "src/large-file.ts";
+    const numstat = makeNumstatLine(500, 0, filename);
+
+    // Build a unified diff larger than 500KB
+    const headerLines = makeUnifiedHeader(filename);
+    const hunkLines = Array.from({ length: 500 }, (_, i) => `+added line ${i}`).join("\n");
+    const diffContent = `${headerLines}\n@@ -0,0 +1,500 @@\n${hunkLines}\n`;
+
+    // Pad to exceed 500KB
+    const padding = "// padding\n".repeat(Math.ceil((500 * 1024) / 11));
+    const paddedDiff = `${diffContent}${makeUnifiedHeader("src/pad.ts")}\n${padding}`;
+
+    const paddedNumstat = `${numstat}\n${makeNumstatLine(0, 0, "src/pad.ts")}`;
+
+    const result = parseDiffOutput(paddedNumstat, paddedDiff);
+
+    // Large file's patch should be truncated
+    const largePatch = result.files.find((f) => f.filename === filename);
+    expect(largePatch).toBeDefined();
+    const patchLines = largePatch!.patch.split("\n");
+    // After truncation: at most 200 lines content + 1 truncation line
+    expect(patchLines.length).toBeLessThanOrEqual(201);
+    expect(largePatch!.patch).toContain("... (truncated)");
+  });
+
+  it("does NOT truncate patches when total diff is under 500KB", () => {
+    const filename = "src/small-file.ts";
+    const numstat = makeNumstatLine(3, 1, filename);
+    const unified =
+      makeUnifiedHeader(filename) +
+      "\n" +
+      makeHunk("ctx", "add line", "remove line") +
+      "\n";
+
+    const result = parseDiffOutput(numstat, unified);
+
+    expect(result.files[0].patch).not.toContain("... (truncated)");
+  });
+});
+
+describe("parseDiffOutput — malformed numstat lines", () => {
+  it("skips lines with fewer than 3 tab-separated parts", () => {
+    const numstat = "bad line\n5\t3\tsrc/valid.ts";
+    const unified = makeUnifiedHeader("src/valid.ts") + "\n" + makeHunk("ctx", "add", "rm") + "\n";
+
+    const result = parseDiffOutput(numstat, unified);
+
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].filename).toBe("src/valid.ts");
+  });
+
+  it("treats non-numeric added/removed as 0", () => {
+    // "xyz" parsed as parseInt → 0
+    const numstat = "xyz\tabc\tsrc/weird.ts";
+    const result = parseDiffOutput(numstat, "");
+    expect(result.files[0].added).toBe(0);
+    expect(result.files[0].removed).toBe(0);
+  });
+});

package/src/lib/__tests__/execution-summary.test.ts

@@ -0,0 +1,237 @@
+// @vitest-environment node
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock modules BEFORE imports to ensure correct hoisting
+vi.mock("@/lib/db", () => ({
+  db: {
+    taskExecution: {
+      update: vi.fn().mockResolvedValue({}),
+    },
+  },
+}));
+
+vi.mock("@/lib/claude-session", () => ({
+  generateSummaryFromLog: vi.fn().mockResolvedValue(null),
+}));
+
+vi.mock("child_process", () => ({
+  execFileSync: vi.fn(),
+}));
+
+vi.mock("fs", () => ({
+  existsSync: vi.fn(),
+}));
+
+import { captureExecutionSummary } from "../execution-summary";
+import { db } from "@/lib/db";
+import { generateSummaryFromLog } from "@/lib/claude-session";
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+
+// Typed mock helpers
+const mockUpdate = vi.mocked(db.taskExecution.update);
+const mockGenerateSummaryFromLog = vi.mocked(generateSummaryFromLog);
+const mockExecFileSync = vi.mocked(execFileSync);
+const mockExistsSync = vi.mocked(existsSync);
+
+// Helper: configure execFileSync to return expected git output based on args
+function setupGitMocks(options?: {
+  gitDir?: string;
+  mergeBase?: string;
+  gitLog?: string;
+  diffStat?: string;
+}) {
+  const opts = {
+    gitDir: ".git",
+    mergeBase: "abc1234567890",
+    gitLog: "abc1234 feat: add feature\ndef5678 fix: bug fix",
+    diffStat: " 2 files changed, 47 insertions(+), 12 deletions(-)",
+    ...options,
+  };
+
+  mockExecFileSync.mockImplementation((_cmd: unknown, args: unknown) => {
+    const gitArgs = args as string[];
+    const subcmd = gitArgs[0];
+
+    if (subcmd === "rev-parse" && gitArgs[1] === "--git-dir") {
+      return opts.gitDir as unknown as ReturnType<typeof execFileSync>;
+    }
+    if (subcmd === "merge-base") {
+      return opts.mergeBase as unknown as ReturnType<typeof execFileSync>;
+    }
+    if (subcmd === "log") {
+      return opts.gitLog as unknown as ReturnType<typeof execFileSync>;
+    }
+    if (subcmd === "diff" && gitArgs[1] === "--stat") {
+      return opts.diffStat as unknown as ReturnType<typeof execFileSync>;
+    }
+    return "" as unknown as ReturnType<typeof execFileSync>;
+  });
+}
+
+describe("captureExecutionSummary", () => {
+  const EXEC_ID = "exec-abc123";
+  const TASK_ID = "task-xyz456";
+  const WORKTREE = "/some/worktree/path";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Suppress console.error noise from the function's own logging
+    vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("updates DB with git data when worktreePath exists and is a git repo", async () => {
+    mockExistsSync.mockReturnValue(true);
+
+    mockGenerateSummaryFromLog.mockResolvedValue("AI summary");
+    setupGitMocks();
+
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 0, "terminal output", WORKTREE);
+
+    expect(mockUpdate).toHaveBeenCalled();
+    const callData = mockUpdate.mock.calls[0][0];
+    expect(callData.where).toEqual({ id: EXEC_ID });
+    expect(callData.data.exitCode).toBe(0);
+    // sessionId is now reported via PostToolUse hook, not captured here
+    expect(callData.data.sessionId).toBeUndefined();
+    // Git log and stats should be populated
+    expect(callData.data.gitLog).toBeTruthy();
+    expect(callData.data.gitStats).toBeTruthy();
+    // gitStats is JSON string containing commits, filesChanged etc.
+    const parsedStats = JSON.parse(callData.data.gitStats as string);
+    expect(parsedStats.filesChanged).toBe(2);
+    expect(parsedStats.insertions).toBe(47);
+    expect(parsedStats.deletions).toBe(12);
+    expect(parsedStats.commits).toBeGreaterThanOrEqual(1);
+  });
+
+  it("updates DB without git data when worktreePath is null", async () => {
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 1, "some output", null);
+
+    expect(mockUpdate).toHaveBeenCalled();
+    const callData = mockUpdate.mock.calls[0][0];
+    expect(callData.data.exitCode).toBe(1);
+    expect(callData.data.gitLog).toBeNull();
+    expect(callData.data.gitStats).toBeNull();
+  });
+
+  it("updates DB without git data when worktreePath does not exist on filesystem", async () => {
+    mockExistsSync.mockReturnValue(false);
+
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 0, "terminal output", WORKTREE);
+
+    expect(mockUpdate).toHaveBeenCalled();
+    const callData = mockUpdate.mock.calls[0][0];
+    expect(callData.data.gitLog).toBeNull();
+    expect(callData.data.gitStats).toBeNull();
+  });
+
+  it("strips ANSI escape codes from terminal buffer before storing terminalLog", async () => {
+    const ansiBuffer = "\x1b[31mred text\x1b[0m normal text";
+
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 0, ansiBuffer, null);
+
+    const callData = mockUpdate.mock.calls[0][0];
+    const terminalLog = callData.data.terminalLog as string;
+    // ANSI sequences should be stripped
+    expect(terminalLog).not.toContain("\x1b");
+    expect(terminalLog).toContain("red text");
+    expect(terminalLog).toContain("normal text");
+  });
+
+  it("strips OSC sequences from terminal buffer", async () => {
+    const oscBuffer = "\x1b]0;title\x07 visible content";
+
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 0, oscBuffer, null);
+
+    const callData = mockUpdate.mock.calls[0][0];
+    const terminalLog = callData.data.terminalLog as string;
+    expect(terminalLog).not.toContain("\x1b]");
+    expect(terminalLog).toContain("visible content");
+  });
+
+  it("trims large terminal buffer to 10KB (last 10KB kept)", async () => {
+    // Create a 20KB buffer
+    const bigBuffer = "x".repeat(20 * 1024);
+
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 0, bigBuffer, null);
+
+    const callData = mockUpdate.mock.calls[0][0];
+    const terminalLog = callData.data.terminalLog as string;
+    // After ANSI strip (no ANSI here), should be <= 10KB
+    expect(terminalLog.length).toBeLessThanOrEqual(10 * 1024);
+  });
+
+  it("stores null for terminalLog when buffer is empty", async () => {
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 0, "", null);
+
+    const callData = mockUpdate.mock.calls[0][0];
+    expect(callData.data.terminalLog).toBeNull();
+  });
+
+  it("does not throw when DB update fails", async () => {
+    mockUpdate.mockRejectedValueOnce(new Error("DB connection failed"));
+
+    // Should not throw — captureExecutionSummary is designed to never throw
+    await expect(
+      captureExecutionSummary(EXEC_ID, TASK_ID, 0, "output", null)
+    ).resolves.toBeUndefined();
+  });
+
+  it("calls generateSummaryFromLog for background AI summary when terminalLog and worktreePath are present", async () => {
+    mockExistsSync.mockReturnValue(true);
+    mockGenerateSummaryFromLog.mockResolvedValue("Background AI summary");
+    setupGitMocks();
+
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 0, "terminal output", WORKTREE);
+
+    // generateSummaryFromLog should have been called with cleaned terminal log and worktree path
+    expect(mockGenerateSummaryFromLog).toHaveBeenCalled();
+    const [logArg, pathArg] = mockGenerateSummaryFromLog.mock.calls[0];
+    expect(pathArg).toBe(WORKTREE);
+    expect(logArg).not.toContain("\x1b");
+    expect(logArg).toContain("terminal output");
+  });
+
+  it("does not call generateSummaryFromLog when worktreePath is null", async () => {
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 0, "terminal output", null);
+
+    expect(mockGenerateSummaryFromLog).not.toHaveBeenCalled();
+  });
+
+  it("does not call generateSummaryFromLog when terminal buffer is empty", async () => {
+    mockExistsSync.mockReturnValue(true);
+    setupGitMocks();
+
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 0, "", WORKTREE);
+
+    expect(mockGenerateSummaryFromLog).not.toHaveBeenCalled();
+  });
+
+  it("includes correct exitCode in DB update", async () => {
+    await captureExecutionSummary(EXEC_ID, TASK_ID, 42, "output", null);
+
+    const callData = mockUpdate.mock.calls[0][0];
+    expect(callData.data.exitCode).toBe(42);
+  });
+
+  it("handles git command failure gracefully — git data is null, does not throw", async () => {
+    mockExistsSync.mockReturnValue(true);
+    // rev-parse throws — not a git repo
+    mockExecFileSync.mockImplementation(() => {
+      throw new Error("not a git repository");
+    });
+
+    await expect(
+      captureExecutionSummary(EXEC_ID, TASK_ID, 0, "output", WORKTREE)
+    ).resolves.toBeUndefined();
+
+    const callData = mockUpdate.mock.calls[0][0];
+    expect(callData.data.gitLog).toBeNull();
+    expect(callData.data.gitStats).toBeNull();
+  });
+});

package/src/lib/__tests__/file-serve.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, vi } from "vitest";
+import * as path from "node:path";
+
+// Mock tower-dir to return a predictable path
+vi.mock("../tower-dir", () => ({
+  getStorageDir: () => "/mock/tower/storage",
+}));
+
+import { resolveAssetPath, MIME_MAP } from "../file-serve";
+import { localPathToApiUrl } from "../file-serve-client";
+
+// ── resolveAssetPath ──
+
+describe("resolveAssetPath — valid paths", () => {
+  it("returns resolved path under storage/assets/{projectId} for a simple filename", () => {
+    const { resolved, error } = resolveAssetPath("proj123", "image.png");
+    expect(error).toBeNull();
+    expect(resolved).not.toBeNull();
+    expect(resolved!).toContain(path.join("storage", "assets", "proj123", "image.png"));
+  });
+
+  it("returns resolved path for filename with spaces", () => {
+    const { resolved, error } = resolveAssetPath("proj123", "my file.png");
+    expect(error).toBeNull();
+    expect(resolved!).toContain("my file.png");
+  });
+
+  it("returns resolved path for nested filename without traversal", () => {
+    const { resolved, error } = resolveAssetPath("proj123", "subdir/image.png");
+    if (error === null) {
+      expect(resolved!).toContain(path.join("storage", "assets", "proj123"));
+    } else {
+      expect(error).toBe("Invalid path");
+    }
+  });
+});
+
+describe("resolveAssetPath — path traversal blocking", () => {
+  it("blocks simple directory traversal '../../../etc/passwd'", () => {
+    const { resolved, error } = resolveAssetPath("proj123", "../../../etc/passwd");
+    expect(resolved).toBeNull();
+    expect(error).toBe("Invalid path");
+  });
+
+  it("blocks traversal attempting to escape project directory '../../../etc'", () => {
+    const { resolved, error } = resolveAssetPath("proj123", "../../etc");
+    expect(resolved).toBeNull();
+    expect(error).toBe("Invalid path");
+  });
+
+  it("blocks traversal via nested relative path 'sub/../../../etc/passwd'", () => {
+    const { resolved, error } = resolveAssetPath("proj123", "sub/../../../etc/passwd");
+    expect(resolved).toBeNull();
+    expect(error).toBe("Invalid path");
+  });
+
+  it("allows single level up traversal that stays within storage/assets", () => {
+    const { resolved, error } = resolveAssetPath("proj123", "../sibling-proj/secret.txt");
+    expect(error).toBeNull();
+    expect(resolved).not.toBeNull();
+    expect(resolved!).toContain(path.join("storage", "assets", "sibling-proj", "secret.txt"));
+  });
+
+  it("blocks absolute path '/etc/passwd'", () => {
+    const { resolved, error } = resolveAssetPath("proj123", "/etc/passwd");
+    expect(resolved).toBeNull();
+    expect(error).toBe("Invalid path");
+  });
+});
+
+// ── MIME_MAP ──
+
+describe("MIME_MAP", () => {
+  it("maps .png to image/png", () => {
+    expect(MIME_MAP[".png"]).toBe("image/png");
+  });
+
+  it("maps .jpg to image/jpeg", () => {
+    expect(MIME_MAP[".jpg"]).toBe("image/jpeg");
+  });
+
+  it("maps .jpeg to image/jpeg", () => {
+    expect(MIME_MAP[".jpeg"]).toBe("image/jpeg");
+  });
+
+  it("maps .svg to image/svg+xml", () => {
+    expect(MIME_MAP[".svg"]).toBe("image/svg+xml");
+  });
+
+  it("maps .gif to image/gif", () => {
+    expect(MIME_MAP[".gif"]).toBe("image/gif");
+  });
+
+  it("maps .webp to image/webp", () => {
+    expect(MIME_MAP[".webp"]).toBe("image/webp");
+  });
+
+  it("maps .pdf to application/pdf", () => {
+    expect(MIME_MAP[".pdf"]).toBe("application/pdf");
+  });
+
+  it("maps .json to application/json", () => {
+    expect(MIME_MAP[".json"]).toBe("application/json");
+  });
+
+  it("maps .txt to text/plain", () => {
+    expect(MIME_MAP[".txt"]).toBe("text/plain");
+  });
+
+  it("maps .md to text/markdown", () => {
+    expect(MIME_MAP[".md"]).toBe("text/markdown");
+  });
+
+  it("returns undefined for unknown extension .unknown", () => {
+    expect(MIME_MAP[".unknown"]).toBeUndefined();
+  });
+
+  it("returns undefined for .exe (not in map)", () => {
+    expect(MIME_MAP[".exe"]).toBeUndefined();
+  });
+
+  it("returns undefined for empty string key", () => {
+    expect(MIME_MAP[""]).toBeUndefined();
+  });
+});
+
+// ── localPathToApiUrl ──
+
+describe("localPathToApiUrl", () => {
+  it("converts storage/assets path to API URL", () => {
+    const result = localPathToApiUrl("/Users/alice/.tower/storage/assets/abc123/file.png");
+    expect(result).toBe("/api/files/assets/abc123/file.png");
+  });
+
+  it("converts relative storage/assets path to API URL", () => {
+    const result = localPathToApiUrl("storage/assets/abc123/file.png");
+    expect(result).toBe("/api/files/assets/abc123/file.png");
+  });
+
+  it("converts legacy data/assets path to API URL (backward compat)", () => {
+    const result = localPathToApiUrl("data/assets/abc123/file.png");
+    expect(result).toBe("/api/files/assets/abc123/file.png");
+  });
+
+  it("converts path with leading slash /data/assets/... to API URL", () => {
+    const result = localPathToApiUrl("/data/assets/abc123/file.png");
+    expect(result).toBe("/api/files/assets/abc123/file.png");
+  });
+
+  it("converts absolute path ending in data/assets/... to API URL", () => {
+    const result = localPathToApiUrl("/absolute/path/to/data/assets/abc123/file.png");
+    expect(result).toBe("/api/files/assets/abc123/file.png");
+  });
+
+  it("returns input unchanged for unrelated path 'unrelated/path.png'", () => {
+    const result = localPathToApiUrl("unrelated/path.png");
+    expect(result).toBe("unrelated/path.png");
+  });
+
+  it("returns input unchanged for external URL", () => {
+    const url = "https://example.com/image.png";
+    expect(localPathToApiUrl(url)).toBe(url);
+  });
+
+  it("returns input unchanged for path that doesn't match pattern", () => {
+    const p = "cache/abc123/file.png";
+    expect(localPathToApiUrl(p)).toBe(p);
+  });
+
+  it("converts path with project ID containing numbers and letters", () => {
+    const result = localPathToApiUrl("storage/assets/clh1234567890abcdefghij/screenshot.jpg");
+    expect(result).toBe("/api/files/assets/clh1234567890abcdefghij/screenshot.jpg");
+  });
+
+  it("returns input unchanged for empty string", () => {
+    expect(localPathToApiUrl("")).toBe("");
+  });
+});