@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/managed-store.test.ts

@@ -34,9 +34,6 @@ import {
   buildSkillMarkdown,
   createManagedSkill,
   deleteManagedSkill,
-  readSkillVersion,
-  removeSkillsIndexEntry,
-  upsertSkillsIndexEntry,
   validateManagedSkillId,
 } from "../skills/managed-store.js";
 
@@ -48,6 +45,22 @@ afterEach(() => {
   rmSync(join(TEST_DIR, "skills"), { recursive: true, force: true });
 });
 
+interface TestInstallMeta {
+  origin?: string;
+  version?: string;
+  installedAt?: string;
+  installedBy?: string;
+}
+
+function readInstallMetaFile(skillId: string): TestInstallMeta {
+  return JSON.parse(
+    readFileSync(
+      join(TEST_DIR, "skills", skillId, "install-meta.json"),
+      "utf-8",
+    ),
+  );
+}
+
 describe("validateManagedSkillId", () => {
   test("accepts valid slug IDs", () => {
     expect(validateManagedSkillId("my-skill")).toBeNull();
@@ -142,7 +155,7 @@ describe("buildSkillMarkdown", () => {
     });
 
     // Load it back via loadSkillCatalog (which uses parseFrontmatter)
-    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const catalog = loadSkillCatalog();
     const skill = catalog.find((s) => s.id === "roundtrip-test");
     expect(skill).toBeDefined();
     expect(skill!.name).toBe('Say "hello" & back\\slash');
@@ -159,7 +172,7 @@ describe("buildSkillMarkdown", () => {
       bodyMarkdown: "Body.",
     });
 
-    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const catalog = loadSkillCatalog();
     const skill = catalog.find((s) => s.id === "backslash-n-test");
     expect(skill).toBeDefined();
     expect(skill!.name).toBe("path\\name");
@@ -205,7 +218,7 @@ describe("buildSkillMarkdown", () => {
       includes: ["child-x", "child-y"],
     });
 
-    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const catalog = loadSkillCatalog();
     const skill = catalog.find((s) => s.id === "roundtrip-includes");
     expect(skill).toBeDefined();
     expect(skill!.includes).toEqual(["child-x", "child-y"]);
@@ -231,113 +244,6 @@ describe("buildSkillMarkdown", () => {
   });
 });
 
-describe("SKILLS.md index management", () => {
-  test("SKILLS.md is created when absent", () => {
-    upsertSkillsIndexEntry("my-skill");
-    const indexPath = join(TEST_DIR, "skills", "SKILLS.md");
-    expect(existsSync(indexPath)).toBe(true);
-    const content = readFileSync(indexPath, "utf-8");
-    expect(content).toContain("- my-skill");
-  });
-
-  test("index add is idempotent", () => {
-    upsertSkillsIndexEntry("my-skill");
-    upsertSkillsIndexEntry("my-skill");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    const matches = content.match(/- my-skill/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  test("delete removes directory and index entry", () => {
-    // Set up a skill
-    const skillDir = join(TEST_DIR, "skills", "doomed");
-    mkdirSync(skillDir, { recursive: true });
-    writeFileSync(join(skillDir, "SKILL.md"), "test");
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "- doomed\n- survivor\n",
-    );
-
-    const result = deleteManagedSkill("doomed");
-    expect(result.deleted).toBe(true);
-    expect(result.indexUpdated).toBe(true);
-    expect(existsSync(skillDir)).toBe(false);
-
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(content).not.toContain("doomed");
-    expect(content).toContain("survivor");
-  });
-
-  test("upsert recognizes * bullet entries", () => {
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "* existing-skill\n");
-    upsertSkillsIndexEntry("existing-skill");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    const matches = content.match(/existing-skill/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  test("remove handles * bullet entries", () => {
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "* doomed\n- survivor\n",
-    );
-    removeSkillsIndexEntry("doomed");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(content).not.toContain("doomed");
-    expect(content).toContain("survivor");
-  });
-
-  test("remove handles markdown link entries", () => {
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "- [My Skill](my-skill/SKILL.md)\n- survivor\n",
-    );
-    removeSkillsIndexEntry("my-skill");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(content).not.toContain("my-skill");
-    expect(content).toContain("survivor");
-  });
-
-  test("upsert recognizes markdown link entries as existing", () => {
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "- [My Skill](my-skill/SKILL.md)\n",
-    );
-    upsertSkillsIndexEntry("my-skill");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    const matches = content.match(/my-skill/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  test("remove from index handles missing entry gracefully", () => {
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- other-skill\n");
-    removeSkillsIndexEntry("nonexistent");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(content).toContain("other-skill");
-  });
-});
-
 describe("createManagedSkill", () => {
   test("creates skill and writes to expected path", () => {
     const result = createManagedSkill({
@@ -429,35 +335,20 @@ describe("createManagedSkill", () => {
     expect(result.error).toContain("description is required");
   });
 
-  test("updates SKILLS.md index", () => {
+  test("does not create SKILLS.md and is discovered through SKILL.md directory", () => {
     createManagedSkill({
-      id: "indexed-skill",
-      name: "Indexed",
-      description: "Gets indexed",
+      id: "discovered-skill",
+      name: "Discovered",
+      description: "Found by directory discovery",
       bodyMarkdown: "Body.",
     });
 
-    const indexContent = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(indexContent).toContain("- indexed-skill");
-  });
-
-  test("skips index when addToIndex=false", () => {
-    createManagedSkill({
-      id: "no-index",
-      name: "No Index",
-      description: "Not indexed",
-      bodyMarkdown: "Body.",
-      addToIndex: false,
-    });
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
 
-    const indexPath = join(TEST_DIR, "skills", "SKILLS.md");
-    if (existsSync(indexPath)) {
-      const content = readFileSync(indexPath, "utf-8");
-      expect(content).not.toContain("no-index");
-    }
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const skill = catalog.find((s) => s.id === "discovered-skill");
+    expect(skill).toBeDefined();
+    expect(skill!.name).toBe("Discovered");
   });
 });
 
@@ -564,6 +455,9 @@ describe("deleteManagedSkill", () => {
     const result = deleteManagedSkill("to-delete");
     expect(result.deleted).toBe(true);
     expect(existsSync(join(TEST_DIR, "skills", "to-delete"))).toBe(false);
+
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    expect(catalog.find((s) => s.id === "to-delete")).toBeUndefined();
   });
 
   test("returns error for non-existent skill", () => {
@@ -578,75 +472,60 @@ describe("deleteManagedSkill", () => {
     expect(result.error).toContain("traversal");
   });
 
-  test("skips index removal when removeFromIndex=false", () => {
+  test("delete leaves a stale SKILLS.md index unchanged", () => {
     createManagedSkill({
       id: "keep-index",
       name: "Keep Index",
       description: "Index stays",
       bodyMarkdown: "Body.",
     });
+    writeFileSync(
+      join(TEST_DIR, "skills", "SKILLS.md"),
+      "- keep-index\n- survivor\n",
+    );
 
-    const result = deleteManagedSkill("keep-index", false);
+    const result = deleteManagedSkill("keep-index");
     expect(result.deleted).toBe(true);
-    expect(result.indexUpdated).toBe(false);
 
     const indexContent = readFileSync(
       join(TEST_DIR, "skills", "SKILLS.md"),
       "utf-8",
     );
     expect(indexContent).toContain("- keep-index");
+    expect(indexContent).toContain("- survivor");
+
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    expect(catalog.find((s) => s.id === "keep-index")).toBeUndefined();
   });
 
-  test("succeeds even when index cleanup throws", () => {
+  test("delete does not create or edit SKILLS.md", () => {
     createManagedSkill({
-      id: "index-fail",
-      name: "Index Fail",
-      description: "Index removal will throw",
+      id: "delete-no-index",
+      name: "Delete No Index",
+      description: "No index write",
       bodyMarkdown: "Body.",
     });
 
-    // Intercept the atomic write (.tmp- file) used by removeSkillsIndexEntry
     const skillsDir = join(TEST_DIR, "skills");
-    const originalWrite = fs.writeFileSync;
-    const spy = spyOn(fs, "writeFileSync").mockImplementation(((
-      path: fs.PathOrFileDescriptor,
-      data: string | NodeJS.ArrayBufferView,
-      options?: fs.WriteFileOptions,
-    ) => {
-      if (
-        typeof path === "string" &&
-        path.startsWith(skillsDir) &&
-        path.includes(".tmp-")
-      ) {
-        throw new Error("Simulated write failure");
-      }
-      return originalWrite(path, data, options);
-    }) as typeof fs.writeFileSync);
-
-    try {
-      const result = deleteManagedSkill("index-fail");
-      expect(result.deleted).toBe(true);
-      expect(result.indexUpdated).toBe(false);
-      expect(existsSync(join(skillsDir, "index-fail"))).toBe(false);
-    } finally {
-      spy.mockRestore();
-    }
+    const result = deleteManagedSkill("delete-no-index");
+    expect(result.deleted).toBe(true);
+    expect(existsSync(join(skillsDir, "delete-no-index"))).toBe(false);
+    expect(existsSync(join(skillsDir, "SKILLS.md"))).toBe(false);
   });
 });
 
 describe("version metadata", () => {
-  test("readSkillVersion returns null for non-existent skill", () => {
-    expect(readSkillVersion("nonexistent")).toBeNull();
-  });
-
-  test("readSkillVersion returns null when skill exists but has no version.json", () => {
+  test("createManagedSkill writes install-meta.json without version when version is omitted", () => {
     createManagedSkill({
       id: "no-version",
       name: "No Version",
       description: "Created without version",
       bodyMarkdown: "Body.",
     });
-    expect(readSkillVersion("no-version")).toBeNull();
+
+    const meta = readInstallMetaFile("no-version");
+    expect(meta.origin).toBe("custom");
+    expect(meta.version).toBeUndefined();
   });
 
   test("createManagedSkill writes install-meta.json when version is provided", () => {
@@ -658,8 +537,8 @@ describe("version metadata", () => {
       version: "v1:abc123",
     });
 
-    const version = readSkillVersion("versioned");
-    expect(version).toBe("v1:abc123");
+    const meta = readInstallMetaFile("versioned");
+    expect(meta.version).toBe("v1:abc123");
   });
 
   test("install-meta.json contains valid JSON with origin, version, and installedAt", () => {
@@ -678,10 +557,13 @@ describe("version metadata", () => {
       "install-meta.json",
     );
     expect(existsSync(metaPath)).toBe(true);
-    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    const meta = readInstallMetaFile("version-meta");
     expect(meta.origin).toBe("custom");
     expect(meta.version).toBe("v1:deadbeef");
     expect(typeof meta.installedAt).toBe("string");
+    if (typeof meta.installedAt !== "string") {
+      throw new Error("installedAt must be a string");
+    }
     // installedAt should be a valid ISO date
     expect(new Date(meta.installedAt).toISOString()).toBe(meta.installedAt);
   });
@@ -702,7 +584,7 @@ describe("version metadata", () => {
       "install-meta.json",
     );
     expect(existsSync(metaPath)).toBe(true);
-    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    const meta = readInstallMetaFile("with-contact");
     expect(meta.origin).toBe("custom");
     expect(meta.installedBy).toBe("contact-uuid-456");
   });
@@ -715,7 +597,8 @@ describe("version metadata", () => {
       bodyMarkdown: "Body.",
       version: "v1:first",
     });
-    expect(readSkillVersion("update-version")).toBe("v1:first");
+
+    expect(readInstallMetaFile("update-version").version).toBe("v1:first");
 
     createManagedSkill({
       id: "update-version",
@@ -725,28 +608,37 @@ describe("version metadata", () => {
       version: "v1:second",
       overwrite: true,
     });
-    expect(readSkillVersion("update-version")).toBe("v1:second");
+    expect(readInstallMetaFile("update-version").version).toBe("v1:second");
   });
 
-  test("readSkillVersion returns null for corrupted install-meta.json", () => {
+  test("overwrite removes legacy version.json", () => {
     createManagedSkill({
-      id: "corrupt-version",
-      name: "Corrupt",
-      description: "Will corrupt meta file",
+      id: "legacy-version",
+      name: "Legacy",
+      description: "Has legacy metadata",
       bodyMarkdown: "Body.",
-      version: "v1:valid",
+      version: "v1:first",
     });
 
-    // Corrupt the install-meta.json
-    const metaPath = join(
+    const legacyMetaPath = join(
       TEST_DIR,
       "skills",
-      "corrupt-version",
-      "install-meta.json",
+      "legacy-version",
+      "version.json",
     );
-    writeFileSync(metaPath, "{invalid json!!!", "utf-8");
+    writeFileSync(legacyMetaPath, '{"version":"legacy"}', "utf-8");
+    expect(existsSync(legacyMetaPath)).toBe(true);
+
+    createManagedSkill({
+      id: "legacy-version",
+      name: "Legacy Updated",
+      description: "Has current metadata",
+      bodyMarkdown: "Body.",
+      version: "v1:second",
+      overwrite: true,
+    });
 
-    expect(readSkillVersion("corrupt-version")).toBeNull();
+    expect(existsSync(legacyMetaPath)).toBe(false);
   });
 });
 

package/src/__tests__/media-generate-image.test.ts

@@ -81,7 +81,7 @@ let mockManagedProxyContext = {
   assistantApiKey: "",
 };
 
-mock.module("../providers/managed-proxy/context.js", () => ({
+mock.module("../providers/platform-proxy/context.js", () => ({
   buildManagedBaseUrl: async () => mockManagedBaseUrl,
   resolveManagedProxyContext: async () => mockManagedProxyContext,
 }));

package/src/__tests__/memory-retrieval-pipeline.test.ts

@@ -273,7 +273,6 @@ describe("memoryRetrieval pipeline — default vs custom plugin", () => {
       manifest: {
         name: "custom-memory-retrieval",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", memoryApi: "v1" },
       },
       middleware: { memoryRetrieval: customMiddleware },
     };
@@ -318,7 +317,6 @@ describe("memoryRetrieval pipeline — default vs custom plugin", () => {
       manifest: {
         name: "hanging-memory-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", memoryApi: "v1" },
       },
       middleware: { memoryRetrieval: hanging },
     };

package/src/__tests__/messages-after-tiebreaker.test.ts

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+import {
+  countMessagesAfter,
+  getMessagesAfter,
+} from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { conversations, messages } from "../memory/schema.js";
+
+initializeDb();
+
+const CONV_ID = "conv-tiebreaker";
+
+function clearDb(): void {
+  const db = getDb();
+  db.delete(messages).run();
+  db.delete(conversations).run();
+}
+
+function seedConversation(): void {
+  const now = Date.now();
+  getDb()
+    .insert(conversations)
+    .values({
+      id: CONV_ID,
+      title: null,
+      createdAt: now,
+      updatedAt: now,
+      source: "test",
+      conversationType: "default",
+      memoryScopeId: "default",
+    })
+    .run();
+}
+
+function insertMessage(id: string, createdAt: number): void {
+  getDb()
+    .insert(messages)
+    .values({
+      id,
+      conversationId: CONV_ID,
+      role: "user",
+      content: "",
+      createdAt,
+      metadata: null,
+    })
+    .run();
+}
+
+describe("countMessagesAfter / getMessagesAfter — millisecond-collision tie-breaker", () => {
+  beforeEach(() => {
+    clearDb();
+    seedConversation();
+  });
+
+  test("messages sharing a millisecond timestamp with the reference are NOT permanently skipped (countMessagesAfter)", () => {
+    const ts = 1_700_000_000_000;
+    // Both messages share the exact same createdAt — id "b" sorts after
+    // id "a" lexicographically. Without a tie-breaker the second message
+    // would never be counted.
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+
+    expect(countMessagesAfter(CONV_ID, "a")).toBe(1);
+  });
+
+  test("messages sharing a millisecond timestamp with the reference are NOT permanently skipped (getMessagesAfter)", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+
+    const result = getMessagesAfter(CONV_ID, "a");
+    expect(result.map((m) => m.id)).toEqual(["b"]);
+  });
+
+  test("strict-after semantics: a message with id sorting BEFORE the reference but identical timestamp is NOT included", () => {
+    const ts = 1_700_000_000_000;
+    // "a" sorts before "b". Reference is "b", so "a" should be excluded
+    // (strictly-after semantics, not "all rows at the same timestamp").
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+
+    expect(countMessagesAfter(CONV_ID, "b")).toBe(0);
+    expect(getMessagesAfter(CONV_ID, "b")).toEqual([]);
+  });
+
+  test("mixed collision + later timestamps: counts both same-ts tie-breaker rows and strictly-later rows", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+    insertMessage("c", ts);
+    insertMessage("d", ts + 1);
+
+    expect(countMessagesAfter(CONV_ID, "a")).toBe(3);
+    const result = getMessagesAfter(CONV_ID, "a");
+    expect(result.map((m) => m.id)).toEqual(["b", "c", "d"]);
+  });
+
+  test("missing reference returns 0/[] (conservative semantics preserved)", () => {
+    insertMessage("a", 1_700_000_000_000);
+    expect(countMessagesAfter(CONV_ID, "nonexistent")).toBe(0);
+    expect(getMessagesAfter(CONV_ID, "nonexistent")).toEqual([]);
+  });
+
+  test("null/empty reference still returns all messages", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+
+    expect(countMessagesAfter(CONV_ID, null)).toBe(2);
+    expect(countMessagesAfter(CONV_ID, "")).toBe(2);
+    expect(getMessagesAfter(CONV_ID, null)).toHaveLength(2);
+    expect(getMessagesAfter(CONV_ID, "")).toHaveLength(2);
+  });
+});