@runfusion/fusion 0.12.0 → 0.14.0

package/dist/droid-cli/src/__tests__/setup-test-isolation.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+
+const TEMP_HOME_PREFIX = "fn-test-home-";
+
+describe("test isolation setup", () => {
+  it("overrides process.env.HOME to a temp directory", () => {
+    const home = process.env.HOME;
+    const userProfile = process.env.USERPROFILE;
+
+    expect(home).toBeDefined();
+    expect(home).toContain(tmpdir());
+    expect(home).toContain(TEMP_HOME_PREFIX);
+    expect(userProfile).toBe(home);
+  });
+
+  it("resolves homedir() to the temp HOME", () => {
+    const home = homedir();
+
+    expect(home).toContain(tmpdir());
+    expect(home).toContain(TEMP_HOME_PREFIX);
+  });
+
+  it("resolves ~/.pi/agent/AGENTS.md under the temp HOME", () => {
+    const agentsPath = join(homedir(), ".pi", "agent", "AGENTS.md");
+
+    expect(agentsPath).toContain(tmpdir());
+    expect(agentsPath).toContain(TEMP_HOME_PREFIX);
+    expect(agentsPath).toMatch(/fn-test-home-.*[\\/]\.pi[\\/]agent[\\/]AGENTS\.md$/);
+  });
+});

package/dist/droid-cli/src/__tests__/setup-test-isolation.ts

@@ -0,0 +1,14 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const tempHome = mkdtempSync(join(tmpdir(), "fn-test-home-"));
+process.env.HOME = tempHome;
+process.env.USERPROFILE = tempHome;
+if (process.platform === "win32") {
+  const match = tempHome.match(/^([A-Za-z]:)(.*)$/);
+  if (match) {
+    process.env.HOMEDRIVE = match[1];
+    process.env.HOMEPATH = match[2] || "\\";
+  }
+}

package/dist/droid-cli/src/__tests__/stream-parser.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect, vi } from "vitest";
+import { parseLine } from "../stream-parser";
+import type {
+  ClaudeStreamEventMessage,
+  ClaudeResultMessage,
+  ClaudeSystemMessage,
+} from "../types";
+
+describe("parseLine", () => {
+  describe("valid JSON parsing", () => {
+    it("parses a valid stream_event message", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "message_start",
+          message: { usage: { input_tokens: 10 } },
+        },
+      });
+      const result = parseLine(line);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe("stream_event");
+      expect((result as ClaudeStreamEventMessage).event.type).toBe(
+        "message_start",
+      );
+    });
+
+    it("parses a valid result message", () => {
+      const line = JSON.stringify({
+        type: "result",
+        subtype: "success",
+        result: "Hello world",
+      });
+      const result = parseLine(line);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe("result");
+      expect((result as ClaudeResultMessage).subtype).toBe("success");
+      expect((result as ClaudeResultMessage).result).toBe("Hello world");
+    });
+
+    it("parses a valid system message", () => {
+      const line = JSON.stringify({
+        type: "system",
+        subtype: "init",
+        session_id: "test-session",
+      });
+      const result = parseLine(line);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe("system");
+      expect((result as ClaudeSystemMessage).subtype).toBe("init");
+    });
+
+    it("parses a valid control_request message", () => {
+      const line = JSON.stringify({
+        type: "control_request",
+        request_id: "req-001",
+        request: {
+          subtype: "can_use_tool",
+          tool_name: "Read",
+          input: { file_path: "/test" },
+        },
+      });
+      const result = parseLine(line);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe("control_request");
+    });
+  });
+
+  describe("empty and whitespace lines", () => {
+    it("returns null for empty string", () => {
+      expect(parseLine("")).toBeNull();
+    });
+
+    it("returns null for whitespace-only line", () => {
+      expect(parseLine("   ")).toBeNull();
+    });
+
+    it("returns null for tab-only line", () => {
+      expect(parseLine("\t\t")).toBeNull();
+    });
+
+    it("returns null for newline-only line", () => {
+      expect(parseLine("\n")).toBeNull();
+    });
+  });
+
+  describe("non-JSON lines (debug noise)", () => {
+    it("returns null for SandboxDebug output", () => {
+      expect(parseLine("[SandboxDebug] loading config...")).toBeNull();
+    });
+
+    it("returns null for plain text", () => {
+      expect(parseLine("Some debug message")).toBeNull();
+    });
+
+    it("returns null for lines starting with [", () => {
+      expect(parseLine("[INFO] starting up")).toBeNull();
+    });
+
+    it("returns null for lines starting with #", () => {
+      expect(parseLine("# comment")).toBeNull();
+    });
+  });
+
+  describe("malformed JSON", () => {
+    it("returns null for truncated JSON without throwing", () => {
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+      expect(parseLine('{"type":"stream_event","event":')).toBeNull();
+      spy.mockRestore();
+    });
+
+    it("returns null for invalid JSON syntax without throwing", () => {
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+      expect(parseLine("{not valid json}")).toBeNull();
+      spy.mockRestore();
+    });
+
+    it("returns null for JSON with trailing comma without throwing", () => {
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+      expect(parseLine('{"type":"test",}')).toBeNull();
+      spy.mockRestore();
+    });
+  });
+
+  describe("non-object JSON", () => {
+    it("returns null for JSON array", () => {
+      expect(parseLine("[1, 2, 3]")).toBeNull();
+    });
+
+    it("returns null for JSON string", () => {
+      expect(parseLine('"hello"')).toBeNull();
+    });
+
+    it("returns null for JSON number", () => {
+      expect(parseLine("42")).toBeNull();
+    });
+
+    it("returns null for JSON null", () => {
+      expect(parseLine("null")).toBeNull();
+    });
+
+    it("returns null for JSON boolean", () => {
+      expect(parseLine("true")).toBeNull();
+    });
+  });
+
+  describe("whitespace handling", () => {
+    it("trims leading whitespace before parsing", () => {
+      const line = `  ${JSON.stringify({ type: "system", subtype: "init" })}`;
+      const result = parseLine(line);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe("system");
+    });
+
+    it("trims trailing whitespace before parsing", () => {
+      const line = `${JSON.stringify({ type: "system", subtype: "init" })}  `;
+      const result = parseLine(line);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe("system");
+    });
+
+    it("trims both leading and trailing whitespace", () => {
+      const line = `  ${JSON.stringify({ type: "result", subtype: "success" })}  `;
+      const result = parseLine(line);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe("result");
+    });
+  });
+
+  describe("resilience", () => {
+    it("never throws regardless of input", () => {
+      const inputs = [
+        "",
+        "   ",
+        "garbage",
+        "{bad",
+        "null",
+        "undefined",
+        "[1,2]",
+        '{"valid": true}',
+        "[SandboxDebug] test",
+        '{"type":"stream_event","event":{"type":"message_start"}}',
+      ];
+      for (const input of inputs) {
+        expect(() => parseLine(input)).not.toThrow();
+      }
+    });
+  });
+});

package/dist/droid-cli/src/__tests__/thinking-config.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { mapThinkingEffort, isOpusModel } from "../thinking-config";
+import type { ThinkingBudgets } from "@mariozechner/pi-ai";
+
+describe("isOpusModel", () => {
+  it("returns true for claude-opus-4-6-20260301", () => {
+    expect(isOpusModel("claude-opus-4-6-20260301")).toBe(true);
+  });
+
+  it("returns false for claude-sonnet-4-5-20250929", () => {
+    expect(isOpusModel("claude-sonnet-4-5-20250929")).toBe(false);
+  });
+
+  it("returns true for future Opus models (forward-compatible)", () => {
+    expect(isOpusModel("claude-opus-5-20270101")).toBe(true);
+  });
+
+  it("returns false for non-Opus model strings", () => {
+    expect(isOpusModel("claude-haiku-3-5-20240307")).toBe(false);
+  });
+});
+
+describe("mapThinkingEffort", () => {
+  describe("undefined reasoning", () => {
+    it("returns undefined when reasoning is undefined", () => {
+      expect(
+        mapThinkingEffort(undefined, "claude-sonnet-4-5", undefined),
+      ).toBeUndefined();
+    });
+
+    it("returns undefined regardless of model", () => {
+      expect(
+        mapThinkingEffort(undefined, "claude-opus-4-6-20260301", undefined),
+      ).toBeUndefined();
+    });
+  });
+
+  describe("standard (non-Opus) model mapping", () => {
+    const model = "claude-sonnet-4-5";
+
+    it("maps minimal to low", () => {
+      expect(mapThinkingEffort("minimal", model, undefined)).toBe("low");
+    });
+
+    it("maps low to low", () => {
+      expect(mapThinkingEffort("low", model, undefined)).toBe("low");
+    });
+
+    it("maps medium to medium", () => {
+      expect(mapThinkingEffort("medium", model, undefined)).toBe("medium");
+    });
+
+    it("maps high to high", () => {
+      expect(mapThinkingEffort("high", model, undefined)).toBe("high");
+    });
+
+    it("maps xhigh to high (downgrade for non-Opus)", () => {
+      expect(mapThinkingEffort("xhigh", model, undefined)).toBe("high");
+    });
+  });
+
+  describe("Opus model mapping (elevated)", () => {
+    const model = "claude-opus-4-6-20260301";
+
+    it("maps minimal to low", () => {
+      expect(mapThinkingEffort("minimal", model, undefined)).toBe("low");
+    });
+
+    it("maps low to low", () => {
+      expect(mapThinkingEffort("low", model, undefined)).toBe("low");
+    });
+
+    it("maps medium to high (shifted up)", () => {
+      expect(mapThinkingEffort("medium", model, undefined)).toBe("high");
+    });
+
+    it("maps high to max (shifted up)", () => {
+      expect(mapThinkingEffort("high", model, undefined)).toBe("max");
+    });
+
+    it("maps xhigh to max", () => {
+      expect(mapThinkingEffort("xhigh", model, undefined)).toBe("max");
+    });
+  });
+
+  describe("thinkingBudgets warning", () => {
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it("logs console.warn when thinkingBudgets is provided with entries", () => {
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const budgets: ThinkingBudgets = { high: 50000 };
+
+      mapThinkingEffort("high", "claude-sonnet-4-5", budgets);
+
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("thinkingBudgets are not supported"),
+      );
+    });
+
+    it("does not warn when thinkingBudgets is undefined", () => {
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      mapThinkingEffort("high", "claude-sonnet-4-5", undefined);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it("does not warn when thinkingBudgets is empty object", () => {
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      mapThinkingEffort("high", "claude-sonnet-4-5", {} as ThinkingBudgets);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it("still returns correct effort level when budgets trigger warning", () => {
+      vi.spyOn(console, "warn").mockImplementation(() => {});
+      const budgets: ThinkingBudgets = { high: 50000 };
+
+      const result = mapThinkingEffort(
+        "high",
+        "claude-opus-4-6-20260301",
+        budgets,
+      );
+      expect(result).toBe("max");
+    });
+  });
+
+  describe("no modelId defaults to non-Opus behavior", () => {
+    it("uses standard mapping when modelId is undefined", () => {
+      expect(mapThinkingEffort("medium", undefined, undefined)).toBe("medium");
+    });
+
+    it("does not return max for xhigh when modelId is undefined", () => {
+      expect(mapThinkingEffort("xhigh", undefined, undefined)).toBe("high");
+    });
+  });
+});

package/dist/droid-cli/src/__tests__/tool-mapping.test.ts

@@ -0,0 +1,253 @@
+import { describe, it, expect } from "vitest";
+import {
+  TOOL_MAPPINGS,
+  CUSTOM_TOOLS_MCP_PREFIX,
+  mapDroidToolNameToPi,
+  mapPiToolNameToDroid,
+  translateDroidArgsToPi,
+  translatePiArgsToDroid,
+  isCustomToolName,
+} from "../tool-mapping";
+
+describe("tool-mapping", () => {
+  describe("TOOL_MAPPINGS", () => {
+    it("exports 6 tool mappings", () => {
+      expect(TOOL_MAPPINGS).toHaveLength(6);
+    });
+  });
+
+  describe("mapDroidToolNameToPi", () => {
+    it("maps Read to read", () => {
+      expect(mapDroidToolNameToPi("Read")).toBe("read");
+    });
+
+    it("maps Write to write", () => {
+      expect(mapDroidToolNameToPi("Write")).toBe("write");
+    });
+
+    it("maps Edit to edit", () => {
+      expect(mapDroidToolNameToPi("Edit")).toBe("edit");
+    });
+
+    it("maps Bash to bash", () => {
+      expect(mapDroidToolNameToPi("Bash")).toBe("bash");
+    });
+
+    it("maps Grep to grep", () => {
+      expect(mapDroidToolNameToPi("Grep")).toBe("grep");
+    });
+
+    it("maps Glob to find", () => {
+      expect(mapDroidToolNameToPi("Glob")).toBe("find");
+    });
+
+    it("passes through unknown tool names unchanged", () => {
+      expect(mapDroidToolNameToPi("UnknownTool")).toBe("UnknownTool");
+    });
+
+    it("is case-insensitive for Claude tool names", () => {
+      expect(mapDroidToolNameToPi("read")).toBe("read");
+      expect(mapDroidToolNameToPi("READ")).toBe("read");
+    });
+  });
+
+  describe("mapPiToolNameToDroid", () => {
+    it("maps read to Read", () => {
+      expect(mapPiToolNameToDroid("read")).toBe("Read");
+    });
+
+    it("maps write to Write", () => {
+      expect(mapPiToolNameToDroid("write")).toBe("Write");
+    });
+
+    it("maps edit to Edit", () => {
+      expect(mapPiToolNameToDroid("edit")).toBe("Edit");
+    });
+
+    it("maps bash to Bash", () => {
+      expect(mapPiToolNameToDroid("bash")).toBe("Bash");
+    });
+
+    it("maps grep to Grep", () => {
+      expect(mapPiToolNameToDroid("grep")).toBe("Grep");
+    });
+
+    it("maps find to Glob", () => {
+      expect(mapPiToolNameToDroid("find")).toBe("Glob");
+    });
+
+    it("maps glob to Glob (asymmetry: both find and glob map to Glob)", () => {
+      expect(mapPiToolNameToDroid("glob")).toBe("Glob");
+    });
+
+    it("passes through unknown tool names unchanged", () => {
+      expect(mapPiToolNameToDroid("unknownTool")).toBe("unknownTool");
+    });
+  });
+
+  describe("translateDroidArgsToPi", () => {
+    it("renames file_path to path for Read", () => {
+      const result = translateDroidArgsToPi("Read", {
+        file_path: "/foo",
+        offset: 10,
+      });
+      expect(result).toEqual({ path: "/foo", offset: 10 });
+    });
+
+    it("renames file_path to path for Write", () => {
+      const result = translateDroidArgsToPi("Write", {
+        file_path: "/bar",
+        content: "hello",
+      });
+      expect(result).toEqual({ path: "/bar", content: "hello" });
+    });
+
+    it("renames file_path, old_string, new_string for Edit", () => {
+      const result = translateDroidArgsToPi("Edit", {
+        file_path: "/f",
+        old_string: "a",
+        new_string: "b",
+      });
+      expect(result).toEqual({ path: "/f", oldText: "a", newText: "b" });
+    });
+
+    it("passes through Bash args unchanged (no renames)", () => {
+      const result = translateDroidArgsToPi("Bash", { command: "ls" });
+      expect(result).toEqual({ command: "ls" });
+    });
+
+    it("renames head_limit to limit for Grep", () => {
+      const result = translateDroidArgsToPi("Grep", {
+        pattern: "x",
+        head_limit: 5,
+      });
+      expect(result).toEqual({ pattern: "x", limit: 5 });
+    });
+
+    it("passes through Glob args unchanged (no renames)", () => {
+      const result = translateDroidArgsToPi("Glob", { pattern: "*.ts" });
+      expect(result).toEqual({ pattern: "*.ts" });
+    });
+
+    it("passes through args for unknown tools unchanged", () => {
+      const result = translateDroidArgsToPi("UnknownTool", {
+        foo: 1,
+        bar: "baz",
+      });
+      expect(result).toEqual({ foo: 1, bar: "baz" });
+    });
+
+    it("preserves unknown args alongside renamed args", () => {
+      const result = translateDroidArgsToPi("Read", {
+        file_path: "/foo",
+        offset: 10,
+        limit: 50,
+        extra_arg: true,
+      });
+      expect(result).toEqual({
+        path: "/foo",
+        offset: 10,
+        limit: 50,
+        extra_arg: true,
+      });
+    });
+  });
+
+  describe("translatePiArgsToDroid", () => {
+    it("renames path to file_path for read", () => {
+      const result = translatePiArgsToDroid("read", { path: "/foo" });
+      expect(result).toEqual({ file_path: "/foo" });
+    });
+
+    it("renames path, oldText, newText for edit", () => {
+      const result = translatePiArgsToDroid("edit", {
+        path: "/f",
+        oldText: "a",
+        newText: "b",
+      });
+      expect(result).toEqual({
+        file_path: "/f",
+        old_string: "a",
+        new_string: "b",
+      });
+    });
+
+    it("renames limit to head_limit for grep", () => {
+      const result = translatePiArgsToDroid("grep", {
+        pattern: "x",
+        limit: 5,
+      });
+      expect(result).toEqual({ pattern: "x", head_limit: 5 });
+    });
+
+    it("passes through unknown args alongside renamed args", () => {
+      const result = translatePiArgsToDroid("read", {
+        path: "/foo",
+        offset: 10,
+        extra: "val",
+      });
+      expect(result).toEqual({ file_path: "/foo", offset: 10, extra: "val" });
+    });
+
+    it("passes through args for unknown tools unchanged", () => {
+      const result = translatePiArgsToDroid("unknownTool", { foo: 1 });
+      expect(result).toEqual({ foo: 1 });
+    });
+  });
+
+  describe("MCP prefix stripping", () => {
+    it("strips mcp__custom-tools__ prefix from myTool", () => {
+      expect(mapDroidToolNameToPi("mcp__custom-tools__myTool")).toBe("myTool");
+    });
+
+    it("strips mcp__custom-tools__ prefix from deploy", () => {
+      expect(mapDroidToolNameToPi("mcp__custom-tools__deploy")).toBe("deploy");
+    });
+
+    it("handles empty name after prefix", () => {
+      expect(mapDroidToolNameToPi("mcp__custom-tools__")).toBe("");
+    });
+
+    it("does NOT strip other MCP server prefixes", () => {
+      expect(mapDroidToolNameToPi("mcp__other-server__foo")).toBe(
+        "mcp__other-server__foo",
+      );
+    });
+
+    it("built-in mappings still work alongside MCP prefix stripping", () => {
+      expect(mapDroidToolNameToPi("Read")).toBe("read");
+      expect(mapDroidToolNameToPi("Glob")).toBe("find");
+    });
+
+    it("CUSTOM_TOOLS_MCP_PREFIX is the correct string", () => {
+      expect(CUSTOM_TOOLS_MCP_PREFIX).toBe("mcp__custom-tools__");
+    });
+  });
+
+  describe("isCustomToolName", () => {
+    it("returns true for custom tool names", () => {
+      expect(isCustomToolName("myTool")).toBe(true);
+      expect(isCustomToolName("deploy")).toBe(true);
+      expect(isCustomToolName("ls")).toBe(true);
+    });
+
+    it("returns false for all 6 built-in tool names", () => {
+      expect(isCustomToolName("read")).toBe(false);
+      expect(isCustomToolName("write")).toBe(false);
+      expect(isCustomToolName("edit")).toBe(false);
+      expect(isCustomToolName("bash")).toBe(false);
+      expect(isCustomToolName("grep")).toBe(false);
+      expect(isCustomToolName("find")).toBe(false);
+    });
+  });
+
+  describe("translateDroidArgsToPi with MCP prefix", () => {
+    it("MCP-prefixed custom tool args pass through unchanged", () => {
+      const result = translateDroidArgsToPi("mcp__custom-tools__myTool", {
+        foo: 1,
+        bar: "baz",
+      });
+      expect(result).toEqual({ foo: 1, bar: "baz" });
+    });
+  });
+});