@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/dictation-profile-store.test.ts

@@ -1,78 +1,85 @@
-import { mkdirSync, 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 { mkdirSync, 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 {
   loadConfig,
   resetCache,
   resolveProfile,
   setStorePathOverride,
-} from '../daemon/dictation-profile-store.js';
+} from "../daemon/dictation-profile-store.js";
 
 let testDir: string;
 let testFilePath: string;
 
 beforeEach(() => {
-  testDir = join(tmpdir(), `vellum-test-profiles-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  testDir = join(
+    tmpdir(),
+    `vellum-test-profiles-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
   mkdirSync(testDir, { recursive: true });
-  testFilePath = join(testDir, 'dictation-profiles.json');
+  testFilePath = join(testDir, "dictation-profiles.json");
   setStorePathOverride(testFilePath);
 });
 
 afterEach(() => {
   setStorePathOverride(null);
-  try { rmSync(testDir, { recursive: true, force: true }); } catch {}
+  try {
+    rmSync(testDir, { recursive: true, force: true });
+  } catch {}
 });
 
 function writeConfig(config: unknown): void {
   writeFileSync(testFilePath, JSON.stringify(config, null, 2));
 }
 
-describe('loadConfig', () => {
-  test('returns default config when file is missing or malformed', () => {
+describe("loadConfig", () => {
+  test("returns default config when file is missing or malformed", () => {
     // Missing file
     let config = loadConfig();
     expect(config.profiles).toHaveLength(1);
-    expect(config.profiles[0].id).toBe('general');
+    expect(config.profiles[0].id).toBe("general");
 
     // Malformed JSON
     resetCache();
-    writeFileSync(testFilePath, 'not json');
+    writeFileSync(testFilePath, "not json");
     config = loadConfig();
-    expect(config.profiles[0].id).toBe('general');
+    expect(config.profiles[0].id).toBe("general");
   });
 
-  test('loads valid config from disk', () => {
+  test("loads valid config from disk", () => {
     writeConfig({
       version: 1,
-      defaultProfileId: 'work',
+      defaultProfileId: "work",
       profiles: [
-        { id: 'work', name: 'Work', stylePrompt: 'Be professional' },
-        { id: 'casual', name: 'Casual' },
+        { id: "work", name: "Work", stylePrompt: "Be professional" },
+        { id: "casual", name: "Casual" },
       ],
     });
     const config = loadConfig();
     expect(config.profiles).toHaveLength(2);
-    expect(config.defaultProfileId).toBe('work');
+    expect(config.defaultProfileId).toBe("work");
   });
 
-  test('enforces validation limits', () => {
+  test("enforces validation limits", () => {
     writeConfig({
       version: 1,
-      profiles: [{
-        id: 'test', name: 'Test',
-        stylePrompt: 'x'.repeat(3000),
-        dictionary: [
-          { spoken: 'ok', written: 'okay' },
-          { spoken: 'x'.repeat(201), written: 'bad' },
-        ],
-        snippets: [
-          { trigger: 'brb', expansion: 'be right back' },
-          { trigger: 'good', expansion: 'y'.repeat(5001) },
-        ],
-      }],
+      profiles: [
+        {
+          id: "test",
+          name: "Test",
+          stylePrompt: "x".repeat(3000),
+          dictionary: [
+            { spoken: "ok", written: "okay" },
+            { spoken: "x".repeat(201), written: "bad" },
+          ],
+          snippets: [
+            { trigger: "brb", expansion: "be right back" },
+            { trigger: "good", expansion: "y".repeat(5001) },
+          ],
+        },
+      ],
     });
     const config = loadConfig();
     expect(config.profiles[0].stylePrompt!.length).toBe(2000);
@@ -81,57 +88,64 @@ describe('loadConfig', () => {
   });
 });
 
-describe('resolveProfile', () => {
-  test('resolution precedence: request > app_mapping > default > fallback', () => {
+describe("resolveProfile", () => {
+  test("resolution precedence: request > app_mapping > default > fallback", () => {
     writeConfig({
       version: 1,
-      defaultProfileId: 'default-one',
-      appMappings: [{ profileId: 'mapped', bundleIdentifier: 'com.test.app' }],
+      defaultProfileId: "default-one",
+      appMappings: [{ profileId: "mapped", bundleIdentifier: "com.test.app" }],
       profiles: [
-        { id: 'requested', name: 'Requested' },
-        { id: 'mapped', name: 'Mapped' },
-        { id: 'default-one', name: 'Default' },
+        { id: "requested", name: "Requested" },
+        { id: "mapped", name: "Mapped" },
+        { id: "default-one", name: "Default" },
       ],
     });
 
     // Explicit request wins
-    expect(resolveProfile('com.test.app', 'Test', 'requested').source).toBe('request');
+    expect(resolveProfile("com.test.app", "Test", "requested").source).toBe(
+      "request",
+    );
 
     // App mapping next
-    expect(resolveProfile('com.test.app', 'Test').source).toBe('app_mapping');
+    expect(resolveProfile("com.test.app", "Test").source).toBe("app_mapping");
 
     // Default when no mapping
-    expect(resolveProfile('com.other.app', 'Other').source).toBe('default');
+    expect(resolveProfile("com.other.app", "Other").source).toBe("default");
 
     // Fallback when nothing configured
     resetCache();
-    writeConfig({ version: 1, profiles: [{ id: 'unused', name: 'Unused' }] });
-    expect(resolveProfile('com.other.app', 'Other').source).toBe('fallback');
+    writeConfig({ version: 1, profiles: [{ id: "unused", name: "Unused" }] });
+    expect(resolveProfile("com.other.app", "Other").source).toBe("fallback");
   });
 
-  test('bundleIdentifier match beats appName match', () => {
+  test("bundleIdentifier match beats appName match", () => {
     writeConfig({
       version: 1,
       appMappings: [
-        { profileId: 'by-name', appName: 'Slack' },
-        { profileId: 'by-bundle', bundleIdentifier: 'com.tinyspeck.slackmacgap' },
+        { profileId: "by-name", appName: "Slack" },
+        {
+          profileId: "by-bundle",
+          bundleIdentifier: "com.tinyspeck.slackmacgap",
+        },
       ],
       profiles: [
-        { id: 'by-name', name: 'By Name' },
-        { id: 'by-bundle', name: 'By Bundle' },
+        { id: "by-name", name: "By Name" },
+        { id: "by-bundle", name: "By Bundle" },
       ],
     });
-    expect(resolveProfile('com.tinyspeck.slackmacgap', 'Slack').profile.id).toBe('by-bundle');
+    expect(
+      resolveProfile("com.tinyspeck.slackmacgap", "Slack").profile.id,
+    ).toBe("by-bundle");
   });
 
-  test('skips disabled profiles', () => {
+  test("skips disabled profiles", () => {
     writeConfig({
       version: 1,
-      defaultProfileId: 'disabled',
-      profiles: [{ id: 'disabled', name: 'Disabled', enabled: false }],
+      defaultProfileId: "disabled",
+      profiles: [{ id: "disabled", name: "Disabled", enabled: false }],
     });
-    const result = resolveProfile('com.test.app', 'Test', 'disabled');
-    expect(result.profile.id).toBe('general');
-    expect(result.source).toBe('fallback');
+    const result = resolveProfile("com.test.app", "Test", "disabled");
+    expect(result.profile.id).toBe("general");
+    expect(result.source).toBe("fallback");
   });
 });

package/src/__tests__/dictation-text-processing.test.ts

@@ -1,61 +1,79 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import type { DictationDictionaryEntry,DictationSnippet } from '../daemon/dictation-profile-store.js';
-import { applyDictionary,expandSnippets } from '../daemon/dictation-text-processing.js';
+import type {
+  DictationDictionaryEntry,
+  DictationSnippet,
+} from "../daemon/dictation-profile-store.js";
+import {
+  applyDictionary,
+  expandSnippets,
+} from "../daemon/dictation-text-processing.js";
 
-describe('expandSnippets', () => {
-  test('expands triggers case-insensitively with longest match winning', () => {
+describe("expandSnippets", () => {
+  test("expands triggers case-insensitively with longest match winning", () => {
     const snippets: DictationSnippet[] = [
-      { trigger: 'brb', expansion: 'be right back' },
-      { trigger: 'ttyl', expansion: 'talk to you later' },
+      { trigger: "brb", expansion: "be right back" },
+      { trigger: "ttyl", expansion: "talk to you later" },
     ];
-    expect(expandSnippets('BRB and ttyl', snippets)).toBe('be right back and talk to you later');
+    expect(expandSnippets("BRB and ttyl", snippets)).toBe(
+      "be right back and talk to you later",
+    );
   });
 
-  test('skips disabled snippets', () => {
+  test("skips disabled snippets", () => {
     const snippets: DictationSnippet[] = [
-      { trigger: 'brb', expansion: 'be right back', enabled: false },
+      { trigger: "brb", expansion: "be right back", enabled: false },
     ];
-    expect(expandSnippets('brb soon', snippets)).toBe('brb soon');
+    expect(expandSnippets("brb soon", snippets)).toBe("brb soon");
   });
 
-  test('no recursive expansion', () => {
+  test("no recursive expansion", () => {
     const snippets: DictationSnippet[] = [
-      { trigger: 'a', expansion: 'b' },
-      { trigger: 'b', expansion: 'c' },
+      { trigger: "a", expansion: "b" },
+      { trigger: "b", expansion: "c" },
     ];
-    expect(expandSnippets('a test', snippets)).toBe('b test');
+    expect(expandSnippets("a test", snippets)).toBe("b test");
   });
 
-  test('handles regex special chars and empty inputs', () => {
-    expect(expandSnippets('I love C++ programming', [{ trigger: 'C++', expansion: 'CPP' }])).toBe('I love CPP programming');
-    expect(expandSnippets('', [{ trigger: 'a', expansion: 'b' }])).toBe('');
-    expect(expandSnippets('hello', undefined)).toBe('hello');
+  test("handles regex special chars and empty inputs", () => {
+    expect(
+      expandSnippets("I love C++ programming", [
+        { trigger: "C++", expansion: "CPP" },
+      ]),
+    ).toBe("I love CPP programming");
+    expect(expandSnippets("", [{ trigger: "a", expansion: "b" }])).toBe("");
+    expect(expandSnippets("hello", undefined)).toBe("hello");
   });
 });
 
-describe('applyDictionary', () => {
-  test('replaces whole words case-insensitively by default', () => {
+describe("applyDictionary", () => {
+  test("replaces whole words case-insensitively by default", () => {
     const dict: DictationDictionaryEntry[] = [
-      { spoken: 'gonna', written: 'going to' },
-      { spoken: 'the', written: 'THE' },
+      { spoken: "gonna", written: "going to" },
+      { spoken: "the", written: "THE" },
     ];
-    expect(applyDictionary('Gonna do it', dict)).toBe('going to do it');
-    expect(applyDictionary('the cat is there', dict)).toBe('THE cat is there');
+    expect(applyDictionary("Gonna do it", dict)).toBe("going to do it");
+    expect(applyDictionary("the cat is there", dict)).toBe("THE cat is there");
   });
 
-  test('respects caseSensitive and wholeWord options', () => {
-    expect(applyDictionary('The api is ready', [
-      { spoken: 'API', written: 'Interface', caseSensitive: true },
-    ])).toBe('The api is ready');
+  test("respects caseSensitive and wholeWord options", () => {
+    expect(
+      applyDictionary("The api is ready", [
+        { spoken: "API", written: "Interface", caseSensitive: true },
+      ]),
+    ).toBe("The api is ready");
 
-    expect(applyDictionary('colorful', [
-      { spoken: 'color', written: 'colour', wholeWord: false },
-    ])).toBe('colourful');
+    expect(
+      applyDictionary("colorful", [
+        { spoken: "color", written: "colour", wholeWord: false },
+      ]),
+    ).toBe("colourful");
   });
 
-  test('handles regex special chars and empty inputs', () => {
-    expect(applyDictionary('Use C++ here', [{ spoken: 'C++', written: 'CPP' }])).toBe('Use CPP here');
-    expect(applyDictionary('hello', undefined)).toBe('hello');
+  test("handles regex special chars and empty inputs", () => {
+    expect(
+      applyDictionary("Use C++ here", [{ spoken: "C++", written: "CPP" }]),
+    ).toBe("Use CPP here");
+    expect(applyDictionary("hello", undefined)).toBe("hello");
   });
 });

package/src/__tests__/diff.test.ts

@@ -1,144 +1,148 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { formatDiff, formatNewFileDiff } from '../util/diff.js';
+import { formatDiff, formatNewFileDiff } from "../util/diff.js";
 
 // Strip ANSI codes for easier assertion
-const stripAnsi = (str: string) => str.replace(/\x1b\[[0-9;]*m/g, '');
+const stripAnsi = (str: string) => str.replace(/\x1b\[[0-9;]*m/g, "");
 
-describe('formatDiff', () => {
-  test('returns empty string for identical content', () => {
-    const result = formatDiff('hello\nworld\n', 'hello\nworld\n', 'test.ts');
-    expect(result).toBe('');
+describe("formatDiff", () => {
+  test("returns empty string for identical content", () => {
+    const result = formatDiff("hello\nworld\n", "hello\nworld\n", "test.ts");
+    expect(result).toBe("");
   });
 
-  test('shows single line addition', () => {
-    const old = 'line1\nline2\nline3';
-    const updated = 'line1\nline2\nnew line\nline3';
-    const result = stripAnsi(formatDiff(old, updated, 'test.ts'));
-    expect(result).toContain('--- a/test.ts');
-    expect(result).toContain('+++ b/test.ts');
-    expect(result).toContain('+new line');
-    expect(result).not.toContain('-new line');
+  test("shows single line addition", () => {
+    const old = "line1\nline2\nline3";
+    const updated = "line1\nline2\nnew line\nline3";
+    const result = stripAnsi(formatDiff(old, updated, "test.ts"));
+    expect(result).toContain("--- a/test.ts");
+    expect(result).toContain("+++ b/test.ts");
+    expect(result).toContain("+new line");
+    expect(result).not.toContain("-new line");
   });
 
-  test('shows single line removal', () => {
-    const old = 'line1\nline2\nline3';
-    const updated = 'line1\nline3';
-    const result = stripAnsi(formatDiff(old, updated, 'test.ts'));
-    expect(result).toContain('-line2');
-    expect(result).not.toContain('+line2');
+  test("shows single line removal", () => {
+    const old = "line1\nline2\nline3";
+    const updated = "line1\nline3";
+    const result = stripAnsi(formatDiff(old, updated, "test.ts"));
+    expect(result).toContain("-line2");
+    expect(result).not.toContain("+line2");
   });
 
-  test('shows line replacement', () => {
-    const old = 'const x = 1;\nconst y = 2;\nconst z = 3;';
-    const updated = 'const x = 1;\nconst y = 42;\nconst z = 3;';
-    const result = stripAnsi(formatDiff(old, updated, 'file.ts'));
-    expect(result).toContain('-const y = 2;');
-    expect(result).toContain('+const y = 42;');
+  test("shows line replacement", () => {
+    const old = "const x = 1;\nconst y = 2;\nconst z = 3;";
+    const updated = "const x = 1;\nconst y = 42;\nconst z = 3;";
+    const result = stripAnsi(formatDiff(old, updated, "file.ts"));
+    expect(result).toContain("-const y = 2;");
+    expect(result).toContain("+const y = 42;");
   });
 
-  test('includes context lines', () => {
+  test("includes context lines", () => {
     const lines = Array.from({ length: 10 }, (_, i) => `line${i + 1}`);
-    const old = lines.join('\n');
+    const old = lines.join("\n");
     const newLines = [...lines];
-    newLines[5] = 'CHANGED';
-    const updated = newLines.join('\n');
-    const result = stripAnsi(formatDiff(old, updated, 'ctx.ts'));
+    newLines[5] = "CHANGED";
+    const updated = newLines.join("\n");
+    const result = stripAnsi(formatDiff(old, updated, "ctx.ts"));
     // Should include context before and after the change
-    expect(result).toContain(' line4');
-    expect(result).toContain(' line5');
-    expect(result).toContain('-line6');
-    expect(result).toContain('+CHANGED');
-    expect(result).toContain(' line7');
-    expect(result).toContain(' line8');
+    expect(result).toContain(" line4");
+    expect(result).toContain(" line5");
+    expect(result).toContain("-line6");
+    expect(result).toContain("+CHANGED");
+    expect(result).toContain(" line7");
+    expect(result).toContain(" line8");
   });
 
-  test('handles multi-hunk diffs', () => {
+  test("handles multi-hunk diffs", () => {
     const lines = Array.from({ length: 20 }, (_, i) => `line${i + 1}`);
-    const old = lines.join('\n');
+    const old = lines.join("\n");
     const newLines = [...lines];
-    newLines[2] = 'CHANGED_A';
-    newLines[17] = 'CHANGED_B';
-    const updated = newLines.join('\n');
-    const result = stripAnsi(formatDiff(old, updated, 'multi.ts'));
-    expect(result).toContain('-line3');
-    expect(result).toContain('+CHANGED_A');
-    expect(result).toContain('-line18');
-    expect(result).toContain('+CHANGED_B');
+    newLines[2] = "CHANGED_A";
+    newLines[17] = "CHANGED_B";
+    const updated = newLines.join("\n");
+    const result = stripAnsi(formatDiff(old, updated, "multi.ts"));
+    expect(result).toContain("-line3");
+    expect(result).toContain("+CHANGED_A");
+    expect(result).toContain("-line18");
+    expect(result).toContain("+CHANGED_B");
     // Should have two @@ hunk headers
     const hunkHeaders = result.match(/@@/g);
     expect(hunkHeaders!.length).toBeGreaterThanOrEqual(4); // 2 hunks, each with @@ ... @@
   });
 
-  test('uses ANSI colors for added/removed lines', () => {
-    const old = 'old line';
-    const updated = 'new line';
-    const result = formatDiff(old, updated, 'test.ts');
+  test("uses ANSI colors for added/removed lines", () => {
+    const old = "old line";
+    const updated = "new line";
+    const result = formatDiff(old, updated, "test.ts");
     // Red for removed
-    expect(result).toContain('\x1b[31m-old line\x1b[0m');
+    expect(result).toContain("\x1b[31m-old line\x1b[0m");
     // Green for added
-    expect(result).toContain('\x1b[32m+new line\x1b[0m');
+    expect(result).toContain("\x1b[32m+new line\x1b[0m");
   });
 
-  test('handles empty old content (new file)', () => {
-    const result = stripAnsi(formatDiff('', 'new content\nline 2', 'new.ts'));
-    expect(result).toContain('+new content');
-    expect(result).toContain('+line 2');
+  test("handles empty old content (new file)", () => {
+    const result = stripAnsi(formatDiff("", "new content\nline 2", "new.ts"));
+    expect(result).toContain("+new content");
+    expect(result).toContain("+line 2");
   });
 
-  test('handles empty new content (file deleted)', () => {
-    const result = stripAnsi(formatDiff('old content\nline 2', '', 'del.ts'));
-    expect(result).toContain('-old content');
-    expect(result).toContain('-line 2');
+  test("handles empty new content (file deleted)", () => {
+    const result = stripAnsi(formatDiff("old content\nline 2", "", "del.ts"));
+    expect(result).toContain("-old content");
+    expect(result).toContain("-line 2");
   });
 
-  test('uses a full fallback diff for oversized files without truncation markers', () => {
-    const old = Array.from({ length: 6 }, (_, i) => `old-${i + 1}`).join('\n');
-    const updated = Array.from({ length: 6 }, (_, i) => (i === 3 ? 'new-4' : `old-${i + 1}`)).join('\n');
-    const result = stripAnsi(formatDiff(old, updated, 'oversized.ts', { maxExactLines: 2 }));
-
-    expect(result).toContain('--- a/oversized.ts');
-    expect(result).toContain('+++ b/oversized.ts');
-    expect(result).toContain('-old-4');
-    expect(result).toContain('+new-4');
-    expect(result).not.toContain('Diff too large to display');
+  test("uses a full fallback diff for oversized files without truncation markers", () => {
+    const old = Array.from({ length: 6 }, (_, i) => `old-${i + 1}`).join("\n");
+    const updated = Array.from({ length: 6 }, (_, i) =>
+      i === 3 ? "new-4" : `old-${i + 1}`,
+    ).join("\n");
+    const result = stripAnsi(
+      formatDiff(old, updated, "oversized.ts", { maxExactLines: 2 }),
+    );
+
+    expect(result).toContain("--- a/oversized.ts");
+    expect(result).toContain("+++ b/oversized.ts");
+    expect(result).toContain("-old-4");
+    expect(result).toContain("+new-4");
+    expect(result).not.toContain("Diff too large to display");
   });
 });
 
-describe('formatNewFileDiff', () => {
-  test('shows all lines as additions', () => {
-    const content = 'line1\nline2\nline3';
-    const result = stripAnsi(formatNewFileDiff(content, 'new.ts'));
-    expect(result).toContain('--- /dev/null');
-    expect(result).toContain('+++ b/new.ts');
-    expect(result).toContain('+line1');
-    expect(result).toContain('+line2');
-    expect(result).toContain('+line3');
+describe("formatNewFileDiff", () => {
+  test("shows all lines as additions", () => {
+    const content = "line1\nline2\nline3";
+    const result = stripAnsi(formatNewFileDiff(content, "new.ts"));
+    expect(result).toContain("--- /dev/null");
+    expect(result).toContain("+++ b/new.ts");
+    expect(result).toContain("+line1");
+    expect(result).toContain("+line2");
+    expect(result).toContain("+line3");
   });
 
-  test('truncates long files', () => {
+  test("truncates long files", () => {
     const lines = Array.from({ length: 50 }, (_, i) => `line${i + 1}`);
-    const content = lines.join('\n');
-    const result = stripAnsi(formatNewFileDiff(content, 'big.ts', 10));
-    expect(result).toContain('+line1');
-    expect(result).toContain('+line10');
-    expect(result).not.toContain('+line11');
-    expect(result).toContain('... 40 more lines');
+    const content = lines.join("\n");
+    const result = stripAnsi(formatNewFileDiff(content, "big.ts", 10));
+    expect(result).toContain("+line1");
+    expect(result).toContain("+line10");
+    expect(result).not.toContain("+line11");
+    expect(result).toContain("... 40 more lines");
   });
 
-  test('does not truncate short files', () => {
-    const content = 'a\nb\nc';
-    const result = stripAnsi(formatNewFileDiff(content, 'small.ts'));
-    expect(result).not.toContain('more lines');
+  test("does not truncate short files", () => {
+    const content = "a\nb\nc";
+    const result = stripAnsi(formatNewFileDiff(content, "small.ts"));
+    expect(result).not.toContain("more lines");
   });
 
-  test('allows unbounded output when maxLines is null', () => {
+  test("allows unbounded output when maxLines is null", () => {
     const lines = Array.from({ length: 50 }, (_, i) => `line${i + 1}`);
-    const content = lines.join('\n');
-    const result = stripAnsi(formatNewFileDiff(content, 'all-lines.ts', null));
+    const content = lines.join("\n");
+    const result = stripAnsi(formatNewFileDiff(content, "all-lines.ts", null));
 
-    expect(result).toContain('+line1');
-    expect(result).toContain('+line50');
-    expect(result).not.toContain('more lines');
+    expect(result).toContain("+line1");
+    expect(result).toContain("+line50");
+    expect(result).not.toContain("more lines");
   });
 });