@vellumai/assistant 0.4.17 → 0.4.19

package/src/__tests__/claude-code-tool-profiles.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach,describe, expect, mock, test } from 'bun:test';
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mock the Agent SDK — prevents real subprocess spawning
@@ -8,82 +8,84 @@ const queryMock = mock(() => {
   return {
     async *[Symbol.asyncIterator]() {
       yield {
-        type: 'result' as const,
-        session_id: 'test-session',
-        subtype: 'success' as const,
-        result: 'Done.',
+        type: "result" as const,
+        session_id: "test-session",
+        subtype: "success" as const,
+        result: "Done.",
       };
     },
   };
 });
 
-mock.module('@anthropic-ai/claude-agent-sdk', () => ({
+mock.module("@anthropic-ai/claude-agent-sdk", () => ({
   query: queryMock,
 }));
 
 // Mock logger
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
 // Mock config
-mock.module('../config/loader.js', () => ({
+mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    
-    apiKeys: { anthropic: 'test-key' },
+
+    apiKeys: { anthropic: "test-key" },
   }),
 }));
 
-import { claudeCodeTool } from '../tools/claude-code/claude-code.js';
-import type { ToolContext } from '../tools/types.js';
+import { claudeCodeTool } from "../tools/claude-code/claude-code.js";
+import type { ToolContext } from "../tools/types.js";
 
 function makeContext(overrides?: Partial<ToolContext>): ToolContext {
   return {
-    sessionId: 'test-session',
-    workingDir: '/tmp/test',
-    guardianTrustClass: 'guardian',
+    sessionId: "test-session",
+    workingDir: "/tmp/test",
+    guardianTrustClass: "guardian",
     onOutput: () => {},
     ...overrides,
   } as ToolContext;
 }
 
-describe('claude_code tool profile support', () => {
+describe("claude_code tool profile support", () => {
   beforeEach(() => {
     queryMock.mockClear();
   });
 
-  test('getDefinition includes profile parameter', () => {
+  test("getDefinition includes profile parameter", () => {
     const def = claudeCodeTool.getDefinition();
-    const props = (def.input_schema as Record<string, unknown>).properties as Record<string, unknown>;
+    const props = (def.input_schema as Record<string, unknown>)
+      .properties as Record<string, unknown>;
     expect(props.profile).toBeDefined();
   });
 
-  test('rejects invalid profile', async () => {
+  test("rejects invalid profile", async () => {
     const result = await claudeCodeTool.execute(
-      { prompt: 'test', profile: 'hacker' },
+      { prompt: "test", profile: "hacker" },
       makeContext(),
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain('Invalid profile');
+    expect(result.content).toContain("Invalid profile");
   });
 
-  test('accepts valid profiles without error', async () => {
-    for (const profile of ['general', 'researcher', 'coder', 'reviewer']) {
+  test("accepts valid profiles without error", async () => {
+    for (const profile of ["general", "researcher", "coder", "reviewer"]) {
       queryMock.mockClear();
       const result = await claudeCodeTool.execute(
-        { prompt: 'test', profile },
+        { prompt: "test", profile },
         makeContext(),
       );
       expect(result.isError).toBeFalsy();
     }
   });
 
-  test('omitted profile defaults to general (backward compat)', async () => {
+  test("omitted profile defaults to general (backward compat)", async () => {
     const result = await claudeCodeTool.execute(
-      { prompt: 'test' },
+      { prompt: "test" },
       makeContext(),
     );
     expect(result.isError).toBeFalsy();

package/src/__tests__/clawhub.test.ts

@@ -1,21 +1,27 @@
-import { existsSync,mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mock } from 'bun:test';
-
-let TEST_DIR = '';
-
-mock.module('../util/platform.js', () => ({
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mock } from "bun:test";
+
+let TEST_DIR = "";
+
+mock.module("../util/platform.js", () => ({
   getRootDir: () => TEST_DIR,
-  getWorkspaceSkillsDir: () => join(TEST_DIR, 'skills'),
+  getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
 }));
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
 import {
@@ -23,11 +29,11 @@ import {
   clawhubInstall,
   loadIntegrityManifest,
   verifyAndRecordSkillHash,
-} from '../skills/clawhub.js';
+} from "../skills/clawhub.js";
 
 beforeEach(() => {
-  TEST_DIR = mkdtempSync(join(tmpdir(), 'clawhub-test-'));
-  mkdirSync(join(TEST_DIR, 'skills'), { recursive: true });
+  TEST_DIR = mkdtempSync(join(tmpdir(), "clawhub-test-"));
+  mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
 });
 
 afterEach(() => {
@@ -38,71 +44,71 @@ afterEach(() => {
 // Slug validation (exercised through public API)
 // ---------------------------------------------------------------------------
 
-describe('clawhubInstall slug validation', () => {
-  test('rejects empty slug', async () => {
-    const result = await clawhubInstall('');
+describe("clawhubInstall slug validation", () => {
+  test("rejects empty slug", async () => {
+    const result = await clawhubInstall("");
     expect(result.success).toBe(false);
-    expect(result.error).toContain('Invalid skill slug');
+    expect(result.error).toContain("Invalid skill slug");
   });
 
-  test('rejects slug starting with a dot', async () => {
-    const result = await clawhubInstall('.hidden');
+  test("rejects slug starting with a dot", async () => {
+    const result = await clawhubInstall(".hidden");
     expect(result.success).toBe(false);
-    expect(result.error).toContain('Invalid skill slug');
+    expect(result.error).toContain("Invalid skill slug");
   });
 
-  test('rejects slug starting with a hyphen', async () => {
-    const result = await clawhubInstall('-dashed');
+  test("rejects slug starting with a hyphen", async () => {
+    const result = await clawhubInstall("-dashed");
     expect(result.success).toBe(false);
-    expect(result.error).toContain('Invalid skill slug');
+    expect(result.error).toContain("Invalid skill slug");
   });
 
-  test('rejects slug with path traversal', async () => {
-    const result = await clawhubInstall('../escape');
+  test("rejects slug with path traversal", async () => {
+    const result = await clawhubInstall("../escape");
     expect(result.success).toBe(false);
-    expect(result.error).toContain('Invalid skill slug');
+    expect(result.error).toContain("Invalid skill slug");
   });
 
-  test('rejects slug with spaces', async () => {
-    const result = await clawhubInstall('my skill');
+  test("rejects slug with spaces", async () => {
+    const result = await clawhubInstall("my skill");
     expect(result.success).toBe(false);
-    expect(result.error).toContain('Invalid skill slug');
+    expect(result.error).toContain("Invalid skill slug");
   });
 
-  test('rejects slug with double slash', async () => {
-    const result = await clawhubInstall('ns//skill');
+  test("rejects slug with double slash", async () => {
+    const result = await clawhubInstall("ns//skill");
     expect(result.success).toBe(false);
-    expect(result.error).toContain('Invalid skill slug');
+    expect(result.error).toContain("Invalid skill slug");
   });
 
-  test('rejects slug ending with slash', async () => {
-    const result = await clawhubInstall('skill/');
+  test("rejects slug ending with slash", async () => {
+    const result = await clawhubInstall("skill/");
     expect(result.success).toBe(false);
-    expect(result.error).toContain('Invalid skill slug');
+    expect(result.error).toContain("Invalid skill slug");
   });
 
-  test('rejects slug with special characters', async () => {
-    const result = await clawhubInstall('skill@latest');
+  test("rejects slug with special characters", async () => {
+    const result = await clawhubInstall("skill@latest");
     expect(result.success).toBe(false);
-    expect(result.error).toContain('Invalid skill slug');
+    expect(result.error).toContain("Invalid skill slug");
   });
 });
 
-describe('clawhubInspect slug validation', () => {
-  test('rejects empty slug', async () => {
-    const result = await clawhubInspect('');
-    expect(result.error).toContain('Invalid skill slug');
+describe("clawhubInspect slug validation", () => {
+  test("rejects empty slug", async () => {
+    const result = await clawhubInspect("");
+    expect(result.error).toContain("Invalid skill slug");
     expect(result.data).toBeUndefined();
   });
 
-  test('rejects slug with path traversal', async () => {
-    const result = await clawhubInspect('../../etc/passwd');
-    expect(result.error).toContain('Invalid skill slug');
+  test("rejects slug with path traversal", async () => {
+    const result = await clawhubInspect("../../etc/passwd");
+    expect(result.error).toContain("Invalid skill slug");
   });
 
-  test('rejects slug with spaces', async () => {
-    const result = await clawhubInspect('bad slug');
-    expect(result.error).toContain('Invalid skill slug');
+  test("rejects slug with spaces", async () => {
+    const result = await clawhubInspect("bad slug");
+    expect(result.error).toContain("Invalid skill slug");
   });
 });
 
@@ -111,62 +117,66 @@ describe('clawhubInspect slug validation', () => {
 // which is the code path that reads/writes the manifest.
 // ---------------------------------------------------------------------------
 
-describe('integrity manifest', () => {
+describe("integrity manifest", () => {
   function createSkillFiles(slug: string): void {
-    const skillDir = join(TEST_DIR, 'skills', slug);
+    const skillDir = join(TEST_DIR, "skills", slug);
     mkdirSync(skillDir, { recursive: true });
-    writeFileSync(join(skillDir, 'SKILL.md'), '# Test Skill\n', 'utf-8');
+    writeFileSync(join(skillDir, "SKILL.md"), "# Test Skill\n", "utf-8");
   }
 
-  test('malformed integrity JSON is handled gracefully', () => {
-    const integrityPath = join(TEST_DIR, 'skills', '.integrity.json');
-    writeFileSync(integrityPath, '{not valid json!!!', 'utf-8');
-    createSkillFiles('valid-slug');
+  test("malformed integrity JSON is handled gracefully", () => {
+    const integrityPath = join(TEST_DIR, "skills", ".integrity.json");
+    writeFileSync(integrityPath, "{not valid json!!!", "utf-8");
+    createSkillFiles("valid-slug");
 
     // Should not throw — malformed manifest is replaced with a fresh one
-    verifyAndRecordSkillHash('valid-slug');
+    verifyAndRecordSkillHash("valid-slug");
 
     // Manifest should now contain a valid entry
     const manifest = loadIntegrityManifest();
-    expect(manifest['valid-slug']).toBeDefined();
-    expect(manifest['valid-slug'].sha256).toMatch(/^v2:[0-9a-f]{64}$/);
+    expect(manifest["valid-slug"]).toBeDefined();
+    expect(manifest["valid-slug"].sha256).toMatch(/^v2:[0-9a-f]{64}$/);
   });
 
-  test('missing integrity manifest is created on first install', () => {
-    const integrityPath = join(TEST_DIR, 'skills', '.integrity.json');
+  test("missing integrity manifest is created on first install", () => {
+    const integrityPath = join(TEST_DIR, "skills", ".integrity.json");
     expect(existsSync(integrityPath)).toBe(false);
-    createSkillFiles('new-skill');
+    createSkillFiles("new-skill");
 
-    verifyAndRecordSkillHash('new-skill');
+    verifyAndRecordSkillHash("new-skill");
 
     // Manifest should now exist with the skill's hash
     expect(existsSync(integrityPath)).toBe(true);
     const manifest = loadIntegrityManifest();
-    expect(manifest['new-skill']).toBeDefined();
-    expect(manifest['new-skill'].sha256).toMatch(/^v2:[0-9a-f]{64}$/);
+    expect(manifest["new-skill"]).toBeDefined();
+    expect(manifest["new-skill"].sha256).toMatch(/^v2:[0-9a-f]{64}$/);
   });
 
-  test('re-install with same content preserves hash', () => {
-    createSkillFiles('stable-skill');
+  test("re-install with same content preserves hash", () => {
+    createSkillFiles("stable-skill");
 
-    verifyAndRecordSkillHash('stable-skill');
-    const first = loadIntegrityManifest()['stable-skill'].sha256;
+    verifyAndRecordSkillHash("stable-skill");
+    const first = loadIntegrityManifest()["stable-skill"].sha256;
 
-    verifyAndRecordSkillHash('stable-skill');
-    const second = loadIntegrityManifest()['stable-skill'].sha256;
+    verifyAndRecordSkillHash("stable-skill");
+    const second = loadIntegrityManifest()["stable-skill"].sha256;
 
     expect(first).toBe(second);
   });
 
-  test('re-install with changed content updates hash', () => {
-    createSkillFiles('changing-skill');
-    verifyAndRecordSkillHash('changing-skill');
-    const first = loadIntegrityManifest()['changing-skill'].sha256;
+  test("re-install with changed content updates hash", () => {
+    createSkillFiles("changing-skill");
+    verifyAndRecordSkillHash("changing-skill");
+    const first = loadIntegrityManifest()["changing-skill"].sha256;
 
     // Modify skill content
-    writeFileSync(join(TEST_DIR, 'skills', 'changing-skill', 'SKILL.md'), '# Updated\n', 'utf-8');
-    verifyAndRecordSkillHash('changing-skill');
-    const second = loadIntegrityManifest()['changing-skill'].sha256;
+    writeFileSync(
+      join(TEST_DIR, "skills", "changing-skill", "SKILL.md"),
+      "# Updated\n",
+      "utf-8",
+    );
+    verifyAndRecordSkillHash("changing-skill");
+    const second = loadIntegrityManifest()["changing-skill"].sha256;
 
     expect(first).not.toBe(second);
   });

package/src/__tests__/cli.test.ts

@@ -1,39 +1,43 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
 import {
   formatConfirmationCommandPreview,
   formatConfirmationInputLines,
   sanitizeUrlForDisplay,
-} from '../cli.js';
+} from "../cli.js";
 
-describe('sanitizeUrlForDisplay', () => {
-  test('removes userinfo from absolute URLs', () => {
-    const username = 'user';
-    const credential = ['s', 'e', 'c', 'r', 'e', 't'].join('');
-    const rawUrlObj = new URL('https://example.com/private');
+describe("sanitizeUrlForDisplay", () => {
+  test("removes userinfo from absolute URLs", () => {
+    const username = "user";
+    const credential = ["s", "e", "c", "r", "e", "t"].join("");
+    const rawUrlObj = new URL("https://example.com/private");
     rawUrlObj.username = username;
     rawUrlObj.password = credential;
     const rawUrl = rawUrlObj.href;
 
-    expect(sanitizeUrlForDisplay(rawUrl)).toBe('https://example.com/private');
+    expect(sanitizeUrlForDisplay(rawUrl)).toBe("https://example.com/private");
   });
 
-  test('leaves URLs without userinfo unchanged', () => {
-    expect(sanitizeUrlForDisplay('https://example.com/docs')).toBe('https://example.com/docs');
+  test("leaves URLs without userinfo unchanged", () => {
+    expect(sanitizeUrlForDisplay("https://example.com/docs")).toBe(
+      "https://example.com/docs",
+    );
   });
 
-  test('redacts fallback //userinfo@ patterns when URL parsing fails', () => {
-    const userinfo = ['u', 's', 'e', 'r', ':', 'p', 'w'].join('');
+  test("redacts fallback //userinfo@ patterns when URL parsing fails", () => {
+    const userinfo = ["u", "s", "e", "r", ":", "p", "w"].join("");
     const rawValue = `not-a-url //${userinfo}@example.com`;
 
-    expect(sanitizeUrlForDisplay(rawValue)).toBe('not-a-url //[REDACTED]@example.com');
+    expect(sanitizeUrlForDisplay(rawValue)).toBe(
+      "not-a-url //[REDACTED]@example.com",
+    );
   });
 });
 
-describe('formatConfirmationInputLines', () => {
-  test('preserves full old_string and new_string values without truncation', () => {
-    const oldString = 'old '.repeat(120);
-    const newString = 'new '.repeat(120);
+describe("formatConfirmationInputLines", () => {
+  test("preserves full old_string and new_string values without truncation", () => {
+    const oldString = "old ".repeat(120);
+    const newString = "new ".repeat(120);
     const lines = formatConfirmationInputLines({
       old_string: oldString,
       new_string: newString,
@@ -41,28 +45,24 @@ describe('formatConfirmationInputLines', () => {
 
     expect(lines).toContain(`old_string: ${oldString}`);
     expect(lines).toContain(`new_string: ${newString}`);
-    expect(lines.some((line) => line.includes('...'))).toBe(false);
+    expect(lines.some((line) => line.includes("..."))).toBe(false);
   });
 
-  test('preserves multiline values', () => {
+  test("preserves multiline values", () => {
     const lines = formatConfirmationInputLines({
-      old_string: 'line1\nline2\nline3',
+      old_string: "line1\nline2\nline3",
     });
 
-    expect(lines).toEqual([
-      'old_string: line1',
-      '  line2',
-      '  line3',
-    ]);
+    expect(lines).toEqual(["old_string: line1", "  line2", "  line3"]);
   });
 });
 
-describe('formatConfirmationCommandPreview', () => {
-  test('shows concise file_edit preview', () => {
+describe("formatConfirmationCommandPreview", () => {
+  test("shows concise file_edit preview", () => {
     const preview = formatConfirmationCommandPreview({
-      toolName: 'file_edit',
-      input: { path: '/tmp/sample.txt' },
+      toolName: "file_edit",
+      input: { path: "/tmp/sample.txt" },
     });
-    expect(preview).toBe('edit /tmp/sample.txt');
+    expect(preview).toBe("edit /tmp/sample.txt");
   });
 });

package/src/__tests__/clipboard.test.ts

@@ -1,81 +1,88 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { extractLastCodeBlock, formatSessionForExport } from '../util/clipboard.js';
+import {
+  extractLastCodeBlock,
+  formatSessionForExport,
+} from "../util/clipboard.js";
 
-describe('formatSessionForExport', () => {
-  test('formats user and assistant messages', () => {
+describe("formatSessionForExport", () => {
+  test("formats user and assistant messages", () => {
     const messages = [
-      { role: 'user', text: 'Hello' },
-      { role: 'assistant', text: 'Hi there!' },
+      { role: "user", text: "Hello" },
+      { role: "assistant", text: "Hi there!" },
     ];
-    expect(formatSessionForExport(messages)).toBe('you> Hello\n\nassistant> Hi there!');
+    expect(formatSessionForExport(messages)).toBe(
+      "you> Hello\n\nassistant> Hi there!",
+    );
   });
 
-  test('handles a single message', () => {
-    const messages = [{ role: 'user', text: 'Just me' }];
-    expect(formatSessionForExport(messages)).toBe('you> Just me');
+  test("handles a single message", () => {
+    const messages = [{ role: "user", text: "Just me" }];
+    expect(formatSessionForExport(messages)).toBe("you> Just me");
   });
 
-  test('handles empty messages array', () => {
-    expect(formatSessionForExport([])).toBe('');
+  test("handles empty messages array", () => {
+    expect(formatSessionForExport([])).toBe("");
   });
 
-  test('preserves multiline message text', () => {
-    const messages = [
-      { role: 'assistant', text: 'Line 1\nLine 2\nLine 3' },
-    ];
-    expect(formatSessionForExport(messages)).toBe('assistant> Line 1\nLine 2\nLine 3');
+  test("preserves multiline message text", () => {
+    const messages = [{ role: "assistant", text: "Line 1\nLine 2\nLine 3" }];
+    expect(formatSessionForExport(messages)).toBe(
+      "assistant> Line 1\nLine 2\nLine 3",
+    );
   });
 });
 
-describe('extractLastCodeBlock', () => {
-  test('extracts a simple code block', () => {
-    const text = '```\nhello world\n```';
-    expect(extractLastCodeBlock(text)).toBe('hello world');
+describe("extractLastCodeBlock", () => {
+  test("extracts a simple code block", () => {
+    const text = "```\nhello world\n```";
+    expect(extractLastCodeBlock(text)).toBe("hello world");
   });
 
-  test('extracts code block with language tag', () => {
-    const text = '```typescript\nconst x = 1;\n```';
-    expect(extractLastCodeBlock(text)).toBe('const x = 1;');
+  test("extracts code block with language tag", () => {
+    const text = "```typescript\nconst x = 1;\n```";
+    expect(extractLastCodeBlock(text)).toBe("const x = 1;");
   });
 
-  test('returns the last code block when multiple exist', () => {
-    const text = '```\nfirst\n```\nsome text\n```\nsecond\n```';
-    expect(extractLastCodeBlock(text)).toBe('second');
+  test("returns the last code block when multiple exist", () => {
+    const text = "```\nfirst\n```\nsome text\n```\nsecond\n```";
+    expect(extractLastCodeBlock(text)).toBe("second");
   });
 
-  test('handles empty code blocks', () => {
-    const text = '```\n```';
-    expect(extractLastCodeBlock(text)).toBe('');
+  test("handles empty code blocks", () => {
+    const text = "```\n```";
+    expect(extractLastCodeBlock(text)).toBe("");
   });
 
-  test('handles empty code blocks with language tag', () => {
-    const text = '```python\n```';
-    expect(extractLastCodeBlock(text)).toBe('');
+  test("handles empty code blocks with language tag", () => {
+    const text = "```python\n```";
+    expect(extractLastCodeBlock(text)).toBe("");
   });
 
-  test('does not match inline backticks as closing fence', () => {
+  test("does not match inline backticks as closing fence", () => {
     const text = '```\nconst s = "```"\n```';
     expect(extractLastCodeBlock(text)).toBe('const s = "```"');
   });
 
-  test('handles multi-line code blocks', () => {
-    const text = '```js\nfunction foo() {\n  return 42;\n}\n```';
-    expect(extractLastCodeBlock(text)).toBe('function foo() {\n  return 42;\n}');
+  test("handles multi-line code blocks", () => {
+    const text = "```js\nfunction foo() {\n  return 42;\n}\n```";
+    expect(extractLastCodeBlock(text)).toBe(
+      "function foo() {\n  return 42;\n}",
+    );
   });
 
-  test('returns null when no code blocks exist', () => {
-    expect(extractLastCodeBlock('no code here')).toBeNull();
-    expect(extractLastCodeBlock('`inline code`')).toBeNull();
+  test("returns null when no code blocks exist", () => {
+    expect(extractLastCodeBlock("no code here")).toBeNull();
+    expect(extractLastCodeBlock("`inline code`")).toBeNull();
   });
 
-  test('extracts last block when separated by text', () => {
-    const text = '```\nfirst\n```\nSome explanation\n```\nsecond\n```';
-    expect(extractLastCodeBlock(text)).toBe('second');
+  test("extracts last block when separated by text", () => {
+    const text = "```\nfirst\n```\nSome explanation\n```\nsecond\n```";
+    expect(extractLastCodeBlock(text)).toBe("second");
   });
 
-  test('handles non-empty block followed by empty block with text between', () => {
-    const text = '```\nreal code\n```\nSome text\n```\n```';
-    expect(extractLastCodeBlock(text)).toBe('');
+  test("handles non-empty block followed by empty block with text between", () => {
+    const text = "```\nreal code\n```\nSome text\n```\n```";
+    expect(extractLastCodeBlock(text)).toBe("");
   });
 });