shadow-claw 1.23.4 → 1.24.0

package/src/subsystems/providers/transformers-js-provider.test.ts

@@ -0,0 +1,279 @@
+import { jest } from "@jest/globals";
+
+describe("Transformers.js Provider", () => {
+  let mockWorkerInstance: any;
+  let mockGetConfig: jest.Mock<any>;
+  let mockExecuteTool: jest.Mock<any>;
+  let mockSetPostHandler: jest.Mock<any>;
+
+  beforeEach(() => {
+    jest.resetModules();
+
+    mockGetConfig = jest.fn().mockResolvedValue("auto" as never);
+    mockExecuteTool = jest
+      .fn()
+      .mockResolvedValue("tool success result" as never);
+    mockSetPostHandler = jest.fn();
+
+    mockWorkerInstance = {
+      postMessage: jest.fn((msg: any) => {
+        const { type, payload } = msg;
+        if (type === "load") {
+          setTimeout(() => {
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "progress",
+                payload: {
+                  groupId: payload.groupId,
+                  status: "progress",
+                  loaded: 50,
+                  total: 100,
+                },
+              },
+            });
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "progress",
+                payload: { groupId: payload.groupId, status: "done" },
+              },
+            });
+          }, 0);
+        } else if (type === "generate") {
+          setTimeout(() => {
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "chunk",
+                payload: { groupId: payload.groupId, text: "Hello " },
+              },
+            });
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "thinking-chunk",
+                payload: {
+                  groupId: payload.groupId,
+                  text: "thinking deeply...",
+                },
+              },
+            });
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "done",
+                payload: {
+                  groupId: payload.groupId,
+                  text: "Hello world response",
+                },
+              },
+            });
+          }, 0);
+        }
+      }),
+      onmessage: null,
+    };
+
+    (globalThis as any).Worker = jest
+      .fn()
+      .mockImplementation(() => mockWorkerInstance);
+
+    jest.unstable_mockModule("../../db/getConfig.js", () => ({
+      getConfig: mockGetConfig,
+    }));
+
+    jest.unstable_mockModule("../../worker/utils/executeTool.js", () => ({
+      executeTool: mockExecuteTool,
+    }));
+
+    jest.unstable_mockModule("../../worker/utils/post.js", () => ({
+      post: jest.fn(),
+      setPostHandler: mockSetPostHandler,
+    }));
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("loads model, streams chunks and completes simple response", async () => {
+    const { invokeWithTransformersJs } =
+      await import("./transformers-js-provider.js");
+
+    const emitted: any[] = [];
+    const emit = (msg: any) => {
+      emitted.push(msg);
+    };
+
+    const messages = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Hello" },
+          {
+            type: "attachment",
+            mediaType: "image",
+            fileName: "pic.png",
+            mimeType: "image/png",
+          },
+        ],
+      },
+    ];
+
+    await invokeWithTransformersJs(
+      {} as any,
+      "g1",
+      "You are a helpful assistant.",
+      messages,
+      2048,
+      emit,
+      undefined,
+      [],
+      "Xenova/Qwen1.5-0.5B-Chat",
+    );
+
+    expect(emitted.some((e) => e.type === "model-download-progress")).toBe(
+      true,
+    );
+    expect(emitted.some((e) => e.type === "streaming-start")).toBe(true);
+    expect(
+      emitted.some(
+        (e) => e.type === "streaming-chunk" && e.payload.text === "Hello ",
+      ),
+    ).toBe(true);
+    expect(emitted.some((e) => e.type === "streaming-done")).toBe(true);
+    expect(
+      emitted.some(
+        (e) =>
+          e.type === "response" && e.payload.text === "Hello world response",
+      ),
+    ).toBe(true);
+  });
+
+  it("handles XML <tool_call> output, executes tool, and iterates loop", async () => {
+    let callCount = 0;
+    mockWorkerInstance.postMessage = jest.fn((msg: any) => {
+      const { type, payload } = msg;
+      if (type === "load") {
+        setTimeout(() => {
+          mockWorkerInstance.onmessage?.({
+            data: {
+              type: "progress",
+              payload: { groupId: payload.groupId, status: "done" },
+            },
+          });
+        }, 0);
+      } else if (type === "generate") {
+        callCount++;
+        setTimeout(() => {
+          if (callCount === 1) {
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "done",
+                payload: {
+                  groupId: payload.groupId,
+                  text: '<tool_call>{"name": "web_search", "arguments": {"query": "weather"}}</tool_call>',
+                },
+              },
+            });
+          } else {
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "done",
+                payload: {
+                  groupId: payload.groupId,
+                  text: '{"type":"response","response":"The weather is sunny."}',
+                },
+              },
+            });
+          }
+        }, 0);
+      }
+    });
+
+    const { invokeWithTransformersJs } =
+      await import("./transformers-js-provider.js");
+
+    const emitted: any[] = [];
+    const emit = (msg: any) => {
+      emitted.push(msg);
+    };
+
+    const tools: any[] = [
+      {
+        name: "web_search",
+        description: "Search web",
+        input_schema: { type: "object", properties: {} },
+      },
+    ];
+
+    await invokeWithTransformersJs(
+      {} as any,
+      "g2",
+      "System prompt",
+      [{ role: "user", content: "What is the weather?" }],
+      1024,
+      emit,
+      undefined,
+      tools,
+      "model-id",
+    );
+
+    expect(mockExecuteTool).toHaveBeenCalledWith(
+      {},
+      "web_search",
+      { query: "weather" },
+      "g2",
+      expect.objectContaining({ allowedTools: tools }),
+    );
+    expect(
+      emitted.some(
+        (e) =>
+          e.type === "response" && e.payload.text === "The weather is sunny.",
+      ),
+    ).toBe(true);
+  });
+
+  it("handles worker error rejection during generation", async () => {
+    mockWorkerInstance.postMessage = jest.fn((msg: any) => {
+      const { type, payload } = msg;
+      if (type === "load") {
+        setTimeout(() => {
+          mockWorkerInstance.onmessage?.({
+            data: {
+              type: "progress",
+              payload: { groupId: payload.groupId, status: "done" },
+            },
+          });
+        }, 0);
+      } else if (type === "generate") {
+        setTimeout(() => {
+          mockWorkerInstance.onmessage?.({
+            data: {
+              type: "error",
+              payload: { groupId: payload.groupId, error: "Out of memory" },
+            },
+          });
+        }, 0);
+      }
+    });
+
+    const { invokeWithTransformersJs } =
+      await import("./transformers-js-provider.js");
+
+    const emitted: any[] = [];
+    const emit = (msg: any) => {
+      emitted.push(msg);
+    };
+
+    await expect(
+      invokeWithTransformersJs(
+        {} as any,
+        "g3",
+        "System prompt",
+        [{ role: "user", content: "Hi" }],
+        512,
+        emit,
+        undefined,
+        [],
+        "model-id",
+      ),
+    ).rejects.toBe("Out of memory");
+  });
+});

package/src/subsystems/providers/utils/createModelCacheFetch.test.ts

@@ -2,8 +2,8 @@ import { jest } from "@jest/globals";
 import { createModelCacheFetch } from "./createModelCacheFetch.js";
 
 // Mock Blob and Response for Jest/jsdom
-if (typeof global !== "undefined") {
-  (global as any).Blob = class MockBlob {
+if (typeof globalThis !== "undefined") {
+  (globalThis as any).Blob = class MockBlob {
     private parts: any[];
     public size: number;
     constructor(parts: any[]) {

package/src/subsystems/providers/utils/downloadModelToCache.test.ts

@@ -2,8 +2,8 @@ import { jest } from "@jest/globals";
 import { downloadModelToCache } from "./downloadModelToCache.js";
 
 // jsdom does not implement Blob fully, so we mock it for the tests
-if (typeof global !== "undefined") {
-  (global as any).Blob = class MockBlob {
+if (typeof globalThis !== "undefined") {
+  (globalThis as any).Blob = class MockBlob {
     private parts: any[];
     public size: number;
     constructor(parts: any[]) {

package/src/subsystems/providers/utils/loadModelStream.test.ts

@@ -2,8 +2,8 @@ import { jest } from "@jest/globals";
 import { loadModelStream } from "./loadModelStream.js";
 
 // Mock Blob and Response for Jest/jsdom
-if (typeof global !== "undefined") {
-  (global as any).Blob = class MockBlob {
+if (typeof globalThis !== "undefined") {
+  (globalThis as any).Blob = class MockBlob {
     private parts: any[];
     public size: number;
     constructor(parts: any[]) {

package/src/subsystems/skills/activateSkill.test.ts

@@ -0,0 +1,101 @@
+import { jest } from "@jest/globals";
+
+const mockLoadSkill = jest.fn() as any;
+
+jest.unstable_mockModule("./discoverSkills.js", () => ({
+  loadSkill: mockLoadSkill,
+}));
+
+const { executeActivateSkill } = await import("./activateSkill.js");
+
+describe("executeActivateSkill", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error when skill name is missing or empty", async () => {
+    const res1 = await executeActivateSkill({} as any, {}, "group-1");
+    expect(res1).toBe("Error: activate_skill requires a skill name.");
+
+    const res2 = await executeActivateSkill(
+      {} as any,
+      { name: "   " },
+      "group-1",
+    );
+    expect(res2).toBe("Error: activate_skill requires a skill name.");
+  });
+
+  it("returns error when skill is not found", async () => {
+    mockLoadSkill.mockResolvedValue(null);
+
+    const res = await executeActivateSkill(
+      {} as any,
+      { name: "my-skill" },
+      "group-1",
+    );
+    expect(res).toBe(
+      'Error: skill "my-skill" was not found in this conversation workspace.',
+    );
+  });
+
+  it("returns error when skill disables model invocation", async () => {
+    mockLoadSkill.mockResolvedValue({
+      name: "secret-skill",
+      disableModelInvocation: true,
+    });
+
+    const res = await executeActivateSkill(
+      {} as any,
+      { name: "secret-skill" },
+      "group-1",
+    );
+    expect(res).toBe(
+      'Error: skill "secret-skill" is not available for model-driven activation.',
+    );
+  });
+
+  it("formats skill content without resources", async () => {
+    mockLoadSkill.mockResolvedValue({
+      name: "summarize",
+      body: "Instructions for summarizing texts.",
+      basePath: ".agents/skills/summarize",
+      resources: [],
+    });
+
+    const res = await executeActivateSkill(
+      {} as any,
+      { name: "summarize" },
+      "group-1",
+    );
+    expect(res).toContain('<skill_content name="summarize">');
+    expect(res).toContain("Instructions for summarizing texts.");
+    expect(res).toContain("Skill directory: .agents/skills/summarize");
+    expect(res).not.toContain("<skill_resources>");
+    expect(res).toContain("</skill_content>");
+  });
+
+  it("formats skill content with fallback body and resources", async () => {
+    mockLoadSkill.mockResolvedValue({
+      name: "data-analysis",
+      body: "",
+      basePath: ".agents/skills/data-analysis",
+      resources: [
+        ".agents/skills/data-analysis/template.py",
+        ".agents/skills/data-analysis/data.csv",
+      ],
+    });
+
+    const res = await executeActivateSkill(
+      {} as any,
+      { name: "data-analysis" },
+      "group-1",
+    );
+    expect(res).toContain("(This skill has no instructions.)");
+    expect(res).toContain("<skill_resources>");
+    expect(res).toContain(
+      "<file>.agents/skills/data-analysis/template.py</file>",
+    );
+    expect(res).toContain("<file>.agents/skills/data-analysis/data.csv</file>");
+    expect(res).toContain("</skill_resources>");
+  });
+});

package/src/subsystems/skills/discoverSkills.test.ts

@@ -0,0 +1,251 @@
+import { jest } from "@jest/globals";
+
+const mockGetGroupDir = jest.fn() as any;
+const mockReadGroupFile = jest.fn() as any;
+
+jest.unstable_mockModule("../../storage/getGroupDir.js", () => ({
+  getGroupDir: mockGetGroupDir,
+}));
+
+jest.unstable_mockModule("../../storage/readGroupFile.js", () => ({
+  readGroupFile: mockReadGroupFile,
+}));
+
+const { discoverSkills, loadSkill } = await import("./discoverSkills.js");
+const { DEFAULT_GROUP_ID } = await import("../../config/config.js");
+
+function createMockDirectoryHandle(
+  name: string,
+  children: Record<string, any> = {},
+) {
+  return {
+    kind: "directory",
+    name,
+    getDirectoryHandle: jest.fn(async (childName: string) => {
+      const child = children[childName];
+      if (!child || child.kind !== "directory") {
+        throw new Error(`Directory not found: ${childName}`);
+      }
+      return child;
+    }),
+    entries: async function* () {
+      for (const [childName, child] of Object.entries(children)) {
+        yield [childName, child];
+      }
+    },
+  };
+}
+
+function createMockFileHandle(name: string) {
+  return {
+    kind: "file",
+    name,
+  };
+}
+
+describe("discoverSkills and loadSkill", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns empty results when .agents or .agents/skills does not exist", async () => {
+    const root = createMockDirectoryHandle("root", {});
+    mockGetGroupDir.mockResolvedValue(root);
+
+    const result = await discoverSkills({} as any, DEFAULT_GROUP_ID);
+    expect(result.skills).toEqual([]);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("discovers skills from .agents/skills directory hierarchy", async () => {
+    const skillA = createMockDirectoryHandle("skill-a", {
+      "SKILL.md": createMockFileHandle("SKILL.md"),
+    });
+    const skillsDir = createMockDirectoryHandle("skills", {
+      "skill-a": skillA,
+    });
+    const agentsDir = createMockDirectoryHandle(".agents", {
+      skills: skillsDir,
+    });
+    const root = createMockDirectoryHandle("root", {
+      ".agents": agentsDir,
+    });
+
+    mockGetGroupDir.mockResolvedValue(root);
+    mockReadGroupFile.mockResolvedValue(`---
+name: skill-a
+description: First test skill
+---
+# Skill A Content
+`);
+
+    const result = await discoverSkills({} as any, DEFAULT_GROUP_ID);
+    expect(result.skills).toHaveLength(1);
+    expect(result.skills[0].name).toBe("skill-a");
+    expect(result.skills[0].description).toBe("First test skill");
+    expect(result.skills[0].path).toBe(".agents/skills/skill-a/SKILL.md");
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("records diagnostic when duplicate skill names exist in current group", async () => {
+    const skillA1 = createMockDirectoryHandle("skill-a1", {
+      "SKILL.md": createMockFileHandle("SKILL.md"),
+    });
+    const skillA2 = createMockDirectoryHandle("skill-a2", {
+      "SKILL.md": createMockFileHandle("SKILL.md"),
+    });
+    const skillsDir = createMockDirectoryHandle("skills", {
+      "skill-a1": skillA1,
+      "skill-a2": skillA2,
+    });
+    const agentsDir = createMockDirectoryHandle(".agents", {
+      skills: skillsDir,
+    });
+    const root = createMockDirectoryHandle("root", {
+      ".agents": agentsDir,
+    });
+
+    mockGetGroupDir.mockResolvedValue(root);
+    // Both return the same name "duplicate-skill"
+    mockReadGroupFile.mockResolvedValue(`---
+name: duplicate-skill
+description: Dup skill
+---
+Body
+`);
+
+    const result = await discoverSkills({} as any, DEFAULT_GROUP_ID);
+    expect(result.skills).toHaveLength(1);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0].message).toContain(
+      "Duplicate skill name: duplicate-skill",
+    );
+  });
+
+  it("records diagnostic when skill parsing fails (invalid frontmatter)", async () => {
+    const brokenSkill = createMockDirectoryHandle("broken", {
+      "SKILL.md": createMockFileHandle("SKILL.md"),
+    });
+    const skillsDir = createMockDirectoryHandle("skills", {
+      broken: brokenSkill,
+    });
+    const agentsDir = createMockDirectoryHandle(".agents", {
+      skills: skillsDir,
+    });
+    const root = createMockDirectoryHandle("root", {
+      ".agents": agentsDir,
+    });
+
+    mockGetGroupDir.mockResolvedValue(root);
+    mockReadGroupFile.mockResolvedValue(`invalid content without frontmatter`);
+
+    const result = await discoverSkills({} as any, DEFAULT_GROUP_ID);
+    expect(result.skills).toHaveLength(0);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0].message).toBeTruthy();
+  });
+
+  it("stops and adds diagnostic when visited directories exceeds limit", async () => {
+    const deepChildren: Record<string, any> = {};
+    for (let i = 0; i <= 2001; i++) {
+      deepChildren[`dir_${i}`] = createMockDirectoryHandle(`dir_${i}`, {});
+    }
+
+    const skillsDir = createMockDirectoryHandle("skills", deepChildren);
+    const agentsDir = createMockDirectoryHandle(".agents", {
+      skills: skillsDir,
+    });
+    const root = createMockDirectoryHandle("root", {
+      ".agents": agentsDir,
+    });
+
+    mockGetGroupDir.mockResolvedValue(root);
+
+    const result = await discoverSkills({} as any, DEFAULT_GROUP_ID);
+    expect(
+      result.diagnostics.some((d) =>
+        d.message.includes("stopped after 2000 directories"),
+      ),
+    ).toBe(true);
+  });
+
+  it("scans custom group first then fallback main group", async () => {
+    const rootCustom = createMockDirectoryHandle("rootCustom", {});
+    const skillDefault = createMockDirectoryHandle("default-skill", {
+      "SKILL.md": createMockFileHandle("SKILL.md"),
+    });
+    const skillsDir = createMockDirectoryHandle("skills", {
+      "default-skill": skillDefault,
+    });
+    const agentsDir = createMockDirectoryHandle(".agents", {
+      skills: skillsDir,
+    });
+    const rootDefault = createMockDirectoryHandle("rootDefault", {
+      ".agents": agentsDir,
+    });
+
+    mockGetGroupDir.mockImplementation(async (_db: any, gId: string) => {
+      if (gId === "custom-group") return rootCustom;
+      return rootDefault;
+    });
+
+    mockReadGroupFile.mockResolvedValue(`---
+name: default-skill
+description: Default fallback
+---
+Body
+`);
+
+    const result = await discoverSkills({} as any, "custom-group");
+    expect(result.skills).toHaveLength(1);
+    expect(result.skills[0].name).toBe("default-skill");
+  });
+
+  describe("loadSkill", () => {
+    it("returns null if skill is not found", async () => {
+      const root = createMockDirectoryHandle("root", {});
+      mockGetGroupDir.mockResolvedValue(root);
+
+      const skill = await loadSkill({} as any, DEFAULT_GROUP_ID, "nonexistent");
+      expect(skill).toBeNull();
+    });
+
+    it("loads and refreshes skill with resources", async () => {
+      const helperFile = createMockFileHandle("helper.py");
+      const subFolder = createMockDirectoryHandle("scripts", {
+        "run.sh": createMockFileHandle("run.sh"),
+      });
+      const skillDir = createMockDirectoryHandle("my-skill", {
+        "SKILL.md": createMockFileHandle("SKILL.md"),
+        "helper.py": helperFile,
+        scripts: subFolder,
+      });
+      const skillsDir = createMockDirectoryHandle("skills", {
+        "my-skill": skillDir,
+      });
+      const agentsDir = createMockDirectoryHandle(".agents", {
+        skills: skillsDir,
+      });
+      const root = createMockDirectoryHandle("root", {
+        ".agents": agentsDir,
+      });
+
+      mockGetGroupDir.mockResolvedValue(root);
+      mockReadGroupFile.mockResolvedValue(`---
+name: my-skill
+description: Full loaded skill
+---
+Loaded body instructions
+`);
+
+      const loaded = await loadSkill({} as any, DEFAULT_GROUP_ID, "my-skill");
+      expect(loaded).not.toBeNull();
+      expect(loaded?.name).toBe("my-skill");
+      expect(loaded?.body).toBe("Loaded body instructions");
+      expect(loaded?.resources).toEqual([
+        ".agents/skills/my-skill/helper.py",
+        ".agents/skills/my-skill/scripts/run.sh",
+      ]);
+    });
+  });
+});