@vellumai/assistant 0.5.16 → 0.6.1

package/src/__tests__/install-skill-routing.test.ts

@@ -0,0 +1,293 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+const mockCatalogSkills = mock(
+  (): Array<{
+    id: string;
+    displayName: string;
+    description: string;
+    source: string;
+    directoryPath?: string;
+  }> => [],
+);
+const mockClawhubInstall = mock(
+  async (
+    _slug: string,
+    _opts?: { version?: string },
+  ): Promise<{ success: boolean; error?: string; skillName?: string }> => ({
+    success: true,
+  }),
+);
+const mockInstallExternalSkill = mock(
+  async (
+    _owner: string,
+    _repo: string,
+    _skillSlug: string,
+    _overwrite: boolean,
+    _ref?: string,
+  ): Promise<void> => {},
+);
+const mockGetCatalog = mock(async () => []);
+const mockInstallSkillLocally = mock(async () => {});
+const mockSeedSkillGraphNodes = mock(() => {});
+const mockEnsureSkillEntry = mock(
+  (_raw: Record<string, unknown>, _id: string) => ({
+    enabled: false,
+  }),
+);
+
+// ---------------------------------------------------------------------------
+// Mock modules — before importing module under test
+// ---------------------------------------------------------------------------
+
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: mockCatalogSkills,
+}));
+
+mock.module("../skills/clawhub.js", () => ({
+  clawhubCheckUpdates: mock(async () => []),
+  clawhubInspect: mock(async () => ({})),
+  clawhubInstall: mockClawhubInstall,
+  clawhubSearch: mock(async () => ({ skills: [] })),
+  clawhubUpdate: mock(async () => ({ success: true })),
+}));
+
+mock.module("../skills/skillssh-registry.js", () => ({
+  installExternalSkill: mockInstallExternalSkill,
+  resolveSkillSource: (source: string) => {
+    const parts = source.split("/");
+    if (parts.length >= 3) {
+      return {
+        owner: parts[0]!,
+        repo: parts[1]!,
+        skillSlug: parts.slice(2).join("/"),
+      };
+    }
+    throw new Error(`Invalid skill source "${source}"`);
+  },
+  searchSkillsRegistry: mock(async () => []),
+}));
+
+mock.module("../skills/install-meta.js", () => ({
+  readInstallMeta: () => null,
+}));
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => true,
+}));
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({}),
+  invalidateConfigCache: () => {},
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+}));
+mock.module("../config/skill-state.js", () => ({
+  resolveSkillStates: () => [],
+  skillFlagKey: () => null,
+}));
+mock.module("../providers/provider-send-message.js", () => ({
+  createTimeout: () => ({
+    signal: AbortSignal.timeout(1000),
+    cleanup: () => {},
+  }),
+  extractText: () => "",
+  getConfiguredProvider: async () => null,
+  userMessage: () => ({}),
+}));
+mock.module("../runtime/routes/workspace-utils.js", () => ({
+  isTextMimeType: () => true,
+}));
+mock.module("../skills/catalog-cache.js", () => ({
+  getCatalog: mockGetCatalog,
+}));
+mock.module("../skills/catalog-install.js", () => ({
+  installSkillLocally: mockInstallSkillLocally,
+  upsertSkillsIndex: () => {},
+}));
+mock.module("../skills/catalog-search.js", () => ({
+  filterByQuery: () => [],
+}));
+mock.module("../skills/managed-store.js", () => ({
+  createManagedSkill: () => ({ created: true }),
+  deleteManagedSkill: () => ({ deleted: true }),
+  removeSkillsIndexEntry: () => {},
+  validateManagedSkillId: () => null,
+}));
+mock.module("../memory/graph/capability-seed.js", () => ({
+  deleteSkillCapabilityNode: () => {},
+  seedSkillGraphNodes: mockSeedSkillGraphNodes,
+  seedUninstalledCatalogSkillMemories: async () => {},
+}));
+mock.module("../util/platform.js", () => ({
+  getWorkspaceSkillsDir: () => "/tmp/test-skills",
+}));
+mock.module("../daemon/handlers/shared.js", () => ({
+  CONFIG_RELOAD_DEBOUNCE_MS: 100,
+  ensureSkillEntry: mockEnsureSkillEntry,
+  log: {
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  },
+}));
+
+// Import after mocking
+import { installSkill } from "../daemon/handlers/skills.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const dummyCtx = {
+  debounceTimers: { schedule: () => {} },
+  setSuppressConfigReload: () => {},
+  updateConfigFingerprint: () => {},
+  broadcast: () => {},
+} as unknown as Parameters<typeof installSkill>[1];
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("installSkill routing", () => {
+  beforeEach(() => {
+    mockCatalogSkills.mockReset();
+    mockClawhubInstall.mockReset();
+    mockInstallExternalSkill.mockReset();
+    mockGetCatalog.mockReset();
+    mockInstallSkillLocally.mockReset();
+    mockSeedSkillGraphNodes.mockReset();
+    mockEnsureSkillEntry.mockReset();
+
+    // Defaults
+    mockCatalogSkills.mockReturnValue([]);
+    mockClawhubInstall.mockResolvedValue({ success: true });
+    mockInstallExternalSkill.mockResolvedValue(undefined);
+    mockGetCatalog.mockResolvedValue([]);
+    mockInstallSkillLocally.mockResolvedValue(undefined);
+    mockSeedSkillGraphNodes.mockReturnValue(undefined);
+    mockEnsureSkillEntry.mockReturnValue({ enabled: false });
+  });
+
+  test("install with origin: 'skillssh' and multi-segment slug routes to installExternalSkill", async () => {
+    const result = await installSkill(
+      {
+        slug: "vercel-labs/agent-skills/react-best-practices",
+        origin: "skillssh",
+      },
+      dummyCtx,
+    );
+
+    expect(result.success).toBe(true);
+    expect(mockInstallExternalSkill).toHaveBeenCalledTimes(1);
+    expect(mockInstallExternalSkill).toHaveBeenCalledWith(
+      "vercel-labs",
+      "agent-skills",
+      "react-best-practices",
+      true, // overwrite
+      undefined, // ref
+      undefined, // contactId
+    );
+    // Should not have called clawhub
+    expect(mockClawhubInstall).not.toHaveBeenCalled();
+  });
+
+  test("install without origin falls through to clawhub for simple slugs", async () => {
+    const result = await installSkill({ slug: "some-clawhub-skill" }, dummyCtx);
+
+    expect(result.success).toBe(true);
+    expect(mockClawhubInstall).toHaveBeenCalledTimes(1);
+    expect(mockClawhubInstall).toHaveBeenCalledWith("some-clawhub-skill", {
+      version: undefined,
+    });
+    // Should not have called installExternalSkill
+    expect(mockInstallExternalSkill).not.toHaveBeenCalled();
+  });
+
+  test("install with origin: 'clawhub' routes directly to clawhub without trying skills.sh", async () => {
+    const result = await installSkill(
+      { slug: "my-skill", origin: "clawhub" },
+      dummyCtx,
+    );
+
+    expect(result.success).toBe(true);
+    expect(mockClawhubInstall).toHaveBeenCalledTimes(1);
+    expect(mockInstallExternalSkill).not.toHaveBeenCalled();
+  });
+
+  test("multi-segment slug without explicit origin auto-routes to skills.sh", async () => {
+    const result = await installSkill(
+      { slug: "owner/repo/my-skill" },
+      dummyCtx,
+    );
+
+    expect(result.success).toBe(true);
+    expect(mockInstallExternalSkill).toHaveBeenCalledTimes(1);
+    expect(mockInstallExternalSkill).toHaveBeenCalledWith(
+      "owner",
+      "repo",
+      "my-skill",
+      true,
+      undefined, // ref
+      undefined, // contactId
+    );
+    expect(mockClawhubInstall).not.toHaveBeenCalled();
+  });
+
+  test("multi-segment slug with origin: 'clawhub' skips skills.sh and routes to clawhub", async () => {
+    // Even though the slug looks like skills.sh format, explicit origin: "clawhub"
+    // should override the auto-detection and go to clawhub
+    const result = await installSkill(
+      { slug: "owner/repo/my-skill", origin: "clawhub" },
+      dummyCtx,
+    );
+
+    expect(result.success).toBe(true);
+    expect(mockClawhubInstall).toHaveBeenCalledTimes(1);
+    expect(mockInstallExternalSkill).not.toHaveBeenCalled();
+  });
+
+  test("bundled skills are auto-enabled regardless of origin", async () => {
+    mockCatalogSkills.mockReturnValue([
+      {
+        id: "bundled-skill",
+        displayName: "Bundled Skill",
+        description: "A bundled skill",
+        source: "bundled",
+        directoryPath: "/tmp/test-bundled-skills/bundled-skill",
+      },
+    ]);
+
+    const result = await installSkill(
+      { slug: "bundled-skill", origin: "skillssh" },
+      dummyCtx,
+    );
+
+    expect(result.success).toBe(true);
+    // Should have auto-enabled via ensureSkillEntry, not called external install
+    expect(mockInstallExternalSkill).not.toHaveBeenCalled();
+    expect(mockClawhubInstall).not.toHaveBeenCalled();
+  });
+
+  test("skills.sh install failure propagates error", async () => {
+    mockInstallExternalSkill.mockRejectedValue(
+      new Error("Skill not found in repo"),
+    );
+
+    const result = await installSkill(
+      {
+        slug: "owner/repo/nonexistent-skill",
+        origin: "skillssh",
+      },
+      dummyCtx,
+    );
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Skill not found in repo");
+    }
+  });
+});

package/src/__tests__/invite-redemption-service.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -13,7 +13,7 @@ import {
   upsertContact,
 } from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
-import { getSqlite, initializeDb, resetDb } from "../memory/db.js";
+import { getSqlite, initializeDb } from "../memory/db.js";
 import {
   createInvite,
   revokeInvite as revokeStoreFn,
@@ -27,10 +27,6 @@ import { hashVoiceCode } from "../util/voice-code.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 function resetTables() {
   getSqlite().run("DELETE FROM assistant_ingress_invites");
   getSqlite().run("DELETE FROM contact_channels");

package/src/__tests__/invite-routes-http.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -39,7 +39,7 @@ mock.module("../calls/call-domain.js", () => ({
 }));
 
 import { upsertContact } from "../contacts/contact-store.js";
-import { getSqlite, initializeDb, resetDb } from "../memory/db.js";
+import { getSqlite, initializeDb } from "../memory/db.js";
 import {
   handleCreateInvite,
   handleListInvites,
@@ -55,10 +55,6 @@ function createTargetContact(displayName = "Test Contact"): string {
   return upsertContact({ displayName, role: "contact" }).id;
 }
 
-afterAll(() => {
-  resetDb();
-});
-
 function resetTables() {
   getSqlite().run("DELETE FROM assistant_ingress_invites");
   getSqlite().run("DELETE FROM contact_channels");

package/src/__tests__/jobs-store-qdrant-breaker.test.ts

@@ -1,12 +1,4 @@
-import {
-  afterAll,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
+import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -21,7 +13,7 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import {
   claimMemoryJobs,
   enqueueMemoryJob,
@@ -43,21 +35,17 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     _resetQdrantBreaker();
   });
 
-  afterAll(() => {
-    resetDb();
-  });
-
   test("claims embed jobs when circuit breaker is closed (healthy)", () => {
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
-    enqueueMemoryJob("embed_item", { itemId: "item-1" });
-    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("embed_graph_node", { nodeId: "node-1" });
+    enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
 
     const claimed = claimMemoryJobs(10);
     const types = claimed.map((j) => j.type);
 
     expect(types).toContain("embed_segment");
-    expect(types).toContain("embed_item");
-    expect(types).toContain("extract_items");
+    expect(types).toContain("embed_graph_node");
+    expect(types).toContain("graph_extract");
     expect(claimed).toHaveLength(3);
   });
 
@@ -74,9 +62,9 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     }
 
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
-    enqueueMemoryJob("embed_item", { itemId: "item-1" });
+    enqueueMemoryJob("embed_graph_node", { nodeId: "node-1" });
     enqueueMemoryJob("embed_summary", { summaryId: "sum-1" });
-    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
     enqueueMemoryJob("build_conversation_summary", {
       conversationId: "conv-1",
     });
@@ -85,10 +73,10 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     const types = claimed.map((j) => j.type);
 
     // Only non-embed jobs should be claimed
-    expect(types).toContain("extract_items");
+    expect(types).toContain("graph_extract");
     expect(types).toContain("build_conversation_summary");
     expect(types).not.toContain("embed_segment");
-    expect(types).not.toContain("embed_item");
+    expect(types).not.toContain("embed_graph_node");
     expect(types).not.toContain("embed_summary");
     expect(claimed).toHaveLength(2);
   });
@@ -107,7 +95,7 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
 
     // Verify embed jobs are skipped while open
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
-    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
 
     const claimedWhileOpen = claimMemoryJobs(10);
     expect(claimedWhileOpen.map((j) => j.type)).not.toContain("embed_segment");
@@ -116,21 +104,22 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     _resetQdrantBreaker();
 
     // Re-enqueue an embed job (the previous one is now "running")
-    enqueueMemoryJob("embed_item", { itemId: "item-2" });
+    enqueueMemoryJob("embed_graph_node", { nodeId: "node-2" });
 
     const claimedAfterClose = claimMemoryJobs(10);
     const types = claimedAfterClose.map((j) => j.type);
 
-    expect(types).toContain("embed_item");
+    expect(types).toContain("embed_graph_node");
   });
 
   test("all embed job types are skipped when breaker is open", async () => {
     const embedTypes: MemoryJobType[] = [
       "embed_segment",
-      "embed_item",
       "embed_summary",
       "embed_media",
       "embed_attachment",
+      "embed_graph_node",
+      "graph_trigger_embed",
     ];
 
     // Trip the circuit breaker
@@ -149,13 +138,13 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
       enqueueMemoryJob(type, { id: `test-${type}` });
     }
     // Also enqueue a non-embed job
-    enqueueMemoryJob("extract_entities", { conversationId: "conv-1" });
+    enqueueMemoryJob("graph_consolidate", { conversationId: "conv-1" });
 
     const claimed = claimMemoryJobs(20);
     const types = claimed.map((j) => j.type);
 
     // Only the non-embed job should be claimed
     expect(claimed).toHaveLength(1);
-    expect(types).toEqual(["extract_entities"]);
+    expect(types).toEqual(["graph_consolidate"]);
   });
 });

package/src/__tests__/list-messages-attachments.test.ts

@@ -7,7 +7,7 @@
  * - Assistant message image attachments include base64 data (same as user messages)
  */
 
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -31,15 +31,11 @@ import {
   uploadAttachment,
 } from "../memory/attachments-store.js";
 import { addMessage, createConversation } from "../memory/conversation-crud.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 function resetTables() {
   const db = getDb();
   db.run("DELETE FROM message_attachments");