@vellumai/assistant 0.4.16 → 0.4.18

package/src/__tests__/app-git-history.test.ts

@@ -1,28 +1,39 @@
-import { existsSync, mkdirSync, readFileSync,rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { afterEach, beforeEach, describe, expect, mock,test } from 'bun:test';
-
-import { _resetAppGitState } from '../memory/app-git-service.js';
-import { _resetGitServiceRegistry } from '../workspace/git-service.js';
+import { _resetAppGitState } from "../memory/app-git-service.js";
+import { _resetGitServiceRegistry } from "../workspace/git-service.js";
 
 // Mock getDataDir to use a temp directory
 let testDataDir: string;
 
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getDataDir: () => testDataDir,
   getProjectDir: () => testDataDir,
 }));
 
 // Re-import after mocking so modules use our temp dir
-const { createApp, updateApp, getAppsDir } = await import('../memory/app-store.js');
-const { getAppHistory, getAppDiff, getAppFileAtVersion, restoreAppVersion, commitAppTurnChanges } = await import('../memory/app-git-service.js');
-
-describe('App Git History', () => {
+const { createApp, updateApp, getAppsDir } =
+  await import("../memory/app-store.js");
+const {
+  getAppHistory,
+  getAppDiff,
+  getAppFileAtVersion,
+  restoreAppVersion,
+  commitAppTurnChanges,
+} = await import("../memory/app-git-service.js");
+
+describe("App Git History", () => {
   beforeEach(() => {
-    testDataDir = join(tmpdir(), `vellum-app-git-history-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(join(testDataDir, 'apps'), { recursive: true });
+    testDataDir = join(
+      tmpdir(),
+      `vellum-app-git-history-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`,
+    );
+    mkdirSync(join(testDataDir, "apps"), { recursive: true });
     _resetGitServiceRegistry();
     _resetAppGitState();
   });
@@ -33,38 +44,38 @@ describe('App Git History', () => {
     }
   });
 
-  test('getAppHistory returns commits for a specific app', async () => {
+  test("getAppHistory returns commits for a specific app", async () => {
     const app = createApp({
-      name: 'History App',
-      schemaJson: '{}',
-      htmlDefinition: '<h1>v1</h1>',
+      name: "History App",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>v1</h1>",
     });
-    await commitAppTurnChanges('session-1', 1);
+    await commitAppTurnChanges("session-1", 1);
 
-    updateApp(app.id, { htmlDefinition: '<h1>v2</h1>' });
-    await commitAppTurnChanges('session-1', 2);
+    updateApp(app.id, { htmlDefinition: "<h1>v2</h1>" });
+    await commitAppTurnChanges("session-1", 2);
 
     const history = await getAppHistory(app.id);
     expect(history.length).toBeGreaterThanOrEqual(2);
-    expect(history[0].message).toContain('Turn 2');
+    expect(history[0].message).toContain("Turn 2");
     expect(history[0].commitHash).toMatch(/^[0-9a-f]+$/);
     expect(history[0].timestamp).toBeGreaterThan(0);
   });
 
-  test('getAppHistory does not return commits for other apps', async () => {
+  test("getAppHistory does not return commits for other apps", async () => {
     const app1 = createApp({
-      name: 'App One',
-      schemaJson: '{}',
-      htmlDefinition: '<p>one</p>',
+      name: "App One",
+      schemaJson: "{}",
+      htmlDefinition: "<p>one</p>",
     });
-    await commitAppTurnChanges('session-1', 1);
+    await commitAppTurnChanges("session-1", 1);
 
     const app2 = createApp({
-      name: 'App Two',
-      schemaJson: '{}',
-      htmlDefinition: '<p>two</p>',
+      name: "App Two",
+      schemaJson: "{}",
+      htmlDefinition: "<p>two</p>",
     });
-    await commitAppTurnChanges('session-1', 2);
+    await commitAppTurnChanges("session-1", 2);
 
     const history1 = await getAppHistory(app1.id);
     const history2 = await getAppHistory(app2.id);
@@ -77,97 +88,103 @@ describe('App Git History', () => {
     // (turn 2 created app2, so app2 history should not have turn 1 unless initial commit)
   });
 
-  test('getAppHistory respects limit', async () => {
+  test("getAppHistory respects limit", async () => {
     const app = createApp({
-      name: 'Limited App',
-      schemaJson: '{}',
-      htmlDefinition: '<p>v1</p>',
+      name: "Limited App",
+      schemaJson: "{}",
+      htmlDefinition: "<p>v1</p>",
     });
-    await commitAppTurnChanges('session-1', 1);
+    await commitAppTurnChanges("session-1", 1);
 
-    updateApp(app.id, { htmlDefinition: '<p>v2</p>' });
-    await commitAppTurnChanges('session-1', 2);
+    updateApp(app.id, { htmlDefinition: "<p>v2</p>" });
+    await commitAppTurnChanges("session-1", 2);
 
-    updateApp(app.id, { htmlDefinition: '<p>v3</p>' });
-    await commitAppTurnChanges('session-1', 3);
+    updateApp(app.id, { htmlDefinition: "<p>v3</p>" });
+    await commitAppTurnChanges("session-1", 3);
 
     const limited = await getAppHistory(app.id, 2);
     expect(limited.length).toBe(2);
   });
 
-  test('getAppDiff shows changes between versions', async () => {
+  test("getAppDiff shows changes between versions", async () => {
     const app = createApp({
-      name: 'Diff App',
-      schemaJson: '{}',
-      htmlDefinition: '<p>original</p>',
+      name: "Diff App",
+      schemaJson: "{}",
+      htmlDefinition: "<p>original</p>",
     });
-    await commitAppTurnChanges('session-1', 1);
+    await commitAppTurnChanges("session-1", 1);
 
     const history1 = await getAppHistory(app.id);
     const createHash = history1[0].commitHash;
 
-    updateApp(app.id, { htmlDefinition: '<p>modified</p>' });
-    await commitAppTurnChanges('session-1', 2);
+    updateApp(app.id, { htmlDefinition: "<p>modified</p>" });
+    await commitAppTurnChanges("session-1", 2);
 
     const history2 = await getAppHistory(app.id);
     const updateHash = history2[0].commitHash;
 
     const diff = await getAppDiff(app.id, createHash, updateHash);
-    expect(diff).toContain('original');
-    expect(diff).toContain('modified');
+    expect(diff).toContain("original");
+    expect(diff).toContain("modified");
   });
 
-  test('getAppFileAtVersion returns file content at a specific commit', async () => {
+  test("getAppFileAtVersion returns file content at a specific commit", async () => {
     const app = createApp({
-      name: 'File Version App',
-      schemaJson: '{}',
-      htmlDefinition: '<p>version one</p>',
+      name: "File Version App",
+      schemaJson: "{}",
+      htmlDefinition: "<p>version one</p>",
     });
-    await commitAppTurnChanges('session-1', 1);
+    await commitAppTurnChanges("session-1", 1);
 
     const history1 = await getAppHistory(app.id);
     const v1Hash = history1[0].commitHash;
 
-    updateApp(app.id, { htmlDefinition: '<p>version two</p>' });
-    await commitAppTurnChanges('session-1', 2);
+    updateApp(app.id, { htmlDefinition: "<p>version two</p>" });
+    await commitAppTurnChanges("session-1", 2);
 
     // Get the file at v1 — should show old content
-    const v1Content = await getAppFileAtVersion(app.id, 'index.html', v1Hash);
-    expect(v1Content).toContain('version one');
-    expect(v1Content).not.toContain('version two');
+    const v1Content = await getAppFileAtVersion(app.id, "index.html", v1Hash);
+    expect(v1Content).toContain("version one");
+    expect(v1Content).not.toContain("version two");
 
     // Current file should show new content
-    const currentContent = readFileSync(join(getAppsDir(), app.id, 'index.html'), 'utf-8');
-    expect(currentContent).toContain('version two');
+    const currentContent = readFileSync(
+      join(getAppsDir(), app.id, "index.html"),
+      "utf-8",
+    );
+    expect(currentContent).toContain("version two");
   });
 
-  test('restoreAppVersion restores files and creates a new commit', async () => {
+  test("restoreAppVersion restores files and creates a new commit", async () => {
     const app = createApp({
-      name: 'Restore App',
-      schemaJson: '{}',
-      htmlDefinition: '<p>original content</p>',
+      name: "Restore App",
+      schemaJson: "{}",
+      htmlDefinition: "<p>original content</p>",
     });
-    await commitAppTurnChanges('session-1', 1);
+    await commitAppTurnChanges("session-1", 1);
 
     const history1 = await getAppHistory(app.id);
     const originalHash = history1[0].commitHash;
 
-    updateApp(app.id, { htmlDefinition: '<p>new content</p>' });
-    await commitAppTurnChanges('session-1', 2);
+    updateApp(app.id, { htmlDefinition: "<p>new content</p>" });
+    await commitAppTurnChanges("session-1", 2);
 
     // Verify current content is "new content"
-    let current = readFileSync(join(getAppsDir(), app.id, 'index.html'), 'utf-8');
-    expect(current).toContain('new content');
+    let current = readFileSync(
+      join(getAppsDir(), app.id, "index.html"),
+      "utf-8",
+    );
+    expect(current).toContain("new content");
 
     // Restore to original
     await restoreAppVersion(app.id, originalHash);
 
     // Verify content is restored
-    current = readFileSync(join(getAppsDir(), app.id, 'index.html'), 'utf-8');
-    expect(current).toContain('original content');
+    current = readFileSync(join(getAppsDir(), app.id, "index.html"), "utf-8");
+    expect(current).toContain("original content");
 
     // Verify a restore commit was created
     const history2 = await getAppHistory(app.id);
-    expect(history2[0].message).toContain('Restore app');
+    expect(history2[0].message).toContain("Restore app");
   });
 });

package/src/__tests__/app-git-service.test.ts

@@ -1,28 +1,40 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync,rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, mock,test } from 'bun:test';
-
-import { _resetAppGitState,commitAppTurnChanges } from '../memory/app-git-service.js';
-import { _resetGitServiceRegistry } from '../workspace/git-service.js';
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import {
+  _resetAppGitState,
+  commitAppTurnChanges,
+} from "../memory/app-git-service.js";
+import { _resetGitServiceRegistry } from "../workspace/git-service.js";
 
 // Mock getDataDir to use a temp directory
 let testDataDir: string;
 
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getDataDir: () => testDataDir,
   getProjectDir: () => testDataDir,
 }));
 
 // Re-import app-store after mocking so it uses our temp dir
-const { createApp, updateApp, deleteApp, writeAppFile, editAppFile, getAppsDir } = await import('../memory/app-store.js');
-
-describe('App Git Service', () => {
+const {
+  createApp,
+  updateApp,
+  deleteApp,
+  writeAppFile,
+  editAppFile,
+  getAppsDir,
+} = await import("../memory/app-store.js");
+
+describe("App Git Service", () => {
   beforeEach(() => {
-    testDataDir = join(tmpdir(), `vellum-app-git-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(join(testDataDir, 'apps'), { recursive: true });
+    testDataDir = join(
+      tmpdir(),
+      `vellum-app-git-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(join(testDataDir, "apps"), { recursive: true });
     _resetGitServiceRegistry();
     _resetAppGitState();
   });
@@ -35,53 +47,53 @@ describe('App Git Service', () => {
 
   function getGitLog(dir: string): string[] {
     try {
-      const output = execFileSync('git', ['log', '--oneline', '--format=%s'], {
+      const output = execFileSync("git", ["log", "--oneline", "--format=%s"], {
         cwd: dir,
-        encoding: 'utf-8',
+        encoding: "utf-8",
       });
-      return output.trim().split('\n').filter(Boolean);
+      return output.trim().split("\n").filter(Boolean);
     } catch {
       return [];
     }
   }
 
-  test('.gitignore excludes preview files and records', async () => {
+  test(".gitignore excludes preview files and records", async () => {
     const appsDir = getAppsDir();
-    await commitAppTurnChanges('test-session', 1);
+    await commitAppTurnChanges("test-session", 1);
 
-    const gitignore = readFileSync(join(appsDir, '.gitignore'), 'utf-8');
-    expect(gitignore).toContain('*.preview');
-    expect(gitignore).toContain('*/records/');
+    const gitignore = readFileSync(join(appsDir, ".gitignore"), "utf-8");
+    expect(gitignore).toContain("*.preview");
+    expect(gitignore).toContain("*/records/");
   });
 
-  test('mutations do not auto-commit', async () => {
+  test("mutations do not auto-commit", async () => {
     createApp({
-      name: 'Test App',
-      schemaJson: '{}',
-      htmlDefinition: '<h1>Hello</h1>',
+      name: "Test App",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>Hello</h1>",
     });
 
     // Wait to make sure no fire-and-forget commit happens
-    await new Promise(resolve => setTimeout(resolve, 500));
+    await new Promise((resolve) => setTimeout(resolve, 500));
 
     const appsDir = getAppsDir();
     // No git repo should exist yet since no turn commit was triggered
-    expect(existsSync(join(appsDir, '.git'))).toBe(false);
+    expect(existsSync(join(appsDir, ".git"))).toBe(false);
   });
 
-  test('commitAppTurnChanges creates a single commit for multiple mutations', async () => {
+  test("commitAppTurnChanges creates a single commit for multiple mutations", async () => {
     const app = createApp({
-      name: 'Multi Edit App',
-      schemaJson: '{}',
-      htmlDefinition: '<p>v1</p>',
+      name: "Multi Edit App",
+      schemaJson: "{}",
+      htmlDefinition: "<p>v1</p>",
     });
 
-    updateApp(app.id, { htmlDefinition: '<p>v2</p>' });
-    writeAppFile(app.id, 'styles.css', 'body { color: red; }');
-    editAppFile(app.id, 'index.html', 'v2', 'v3');
+    updateApp(app.id, { htmlDefinition: "<p>v2</p>" });
+    writeAppFile(app.id, "styles.css", "body { color: red; }");
+    editAppFile(app.id, "index.html", "v2", "v3");
 
     // All mutations happened, now commit at turn boundary
-    await commitAppTurnChanges('session-1', 1);
+    await commitAppTurnChanges("session-1", 1);
 
     const appsDir = getAppsDir();
     const commits = getGitLog(appsDir);
@@ -91,47 +103,49 @@ describe('App Git Service', () => {
     // Either way there should be at most 2 commits, not one per mutation.
     expect(commits.length).toBeLessThanOrEqual(2);
     // The turn commit message should appear (or files are in the initial commit)
-    expect(commits.some(c => c.includes('Turn 1') || c.includes('Initial commit'))).toBe(true);
+    expect(
+      commits.some((c) => c.includes("Turn 1") || c.includes("Initial commit")),
+    ).toBe(true);
   });
 
-  test('commitAppTurnChanges does not commit when nothing changed', async () => {
+  test("commitAppTurnChanges does not commit when nothing changed", async () => {
     // Trigger initial commit by creating and committing an app
     createApp({
-      name: 'Static App',
-      schemaJson: '{}',
-      htmlDefinition: '<p>hi</p>',
+      name: "Static App",
+      schemaJson: "{}",
+      htmlDefinition: "<p>hi</p>",
     });
-    await commitAppTurnChanges('session-1', 1);
+    await commitAppTurnChanges("session-1", 1);
 
     const appsDir = getAppsDir();
     const commitsBefore = getGitLog(appsDir);
 
     // No mutations — turn commit should be a no-op
-    await commitAppTurnChanges('session-1', 2);
+    await commitAppTurnChanges("session-1", 2);
 
     const commitsAfter = getGitLog(appsDir);
     expect(commitsAfter.length).toBe(commitsBefore.length);
   });
 
-  test('commitAppTurnChanges swallows errors gracefully', async () => {
+  test("commitAppTurnChanges swallows errors gracefully", async () => {
     _resetAppGitState();
     // This should not throw
-    await commitAppTurnChanges('test', 1);
+    await commitAppTurnChanges("test", 1);
   });
 
-  test('deleteApp changes are captured by turn commit', async () => {
+  test("deleteApp changes are captured by turn commit", async () => {
     const app = createApp({
-      name: 'Doomed App',
-      schemaJson: '{}',
-      htmlDefinition: '<p>bye</p>',
+      name: "Doomed App",
+      schemaJson: "{}",
+      htmlDefinition: "<p>bye</p>",
     });
-    await commitAppTurnChanges('session-1', 1);
+    await commitAppTurnChanges("session-1", 1);
 
     deleteApp(app.id);
-    await commitAppTurnChanges('session-1', 2);
+    await commitAppTurnChanges("session-1", 2);
 
     const appsDir = getAppsDir();
     const commits = getGitLog(appsDir);
-    expect(commits[0]).toContain('Turn 2: app changes');
+    expect(commits[0]).toContain("Turn 2: app changes");
   });
 });

package/src/__tests__/app-open-proxy.test.ts

@@ -1,63 +1,67 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import type { ProxyResolver } from '../tools/apps/executors.js';
-import { openAppViaSurface } from '../tools/apps/open-proxy.js';
+import type { ProxyResolver } from "../tools/apps/executors.js";
+import { openAppViaSurface } from "../tools/apps/open-proxy.js";
 
-describe('openAppViaSurface', () => {
-  test('returns proxy result content on success', async () => {
+describe("openAppViaSurface", () => {
+  test("returns proxy result content on success", async () => {
     const resolver: ProxyResolver = async (_name, _input) => ({
-      content: 'opened-surface-123',
+      content: "opened-surface-123",
       isError: false,
     });
 
-    const result = await openAppViaSurface('app-1', resolver);
-    expect(result).toBe('opened-surface-123');
+    const result = await openAppViaSurface("app-1", resolver);
+    expect(result).toBe("opened-surface-123");
   });
 
-  test('passes app_id and extraInput to the resolver', async () => {
+  test("passes app_id and extraInput to the resolver", async () => {
     let capturedName: string | undefined;
     let capturedInput: Record<string, unknown> | undefined;
 
     const resolver: ProxyResolver = async (name, input) => {
       capturedName = name;
       capturedInput = input;
-      return { content: 'ok', isError: false };
+      return { content: "ok", isError: false };
     };
 
-    await openAppViaSurface('my-app', resolver, { preview: { title: 'Hello' } });
+    await openAppViaSurface("my-app", resolver, {
+      preview: { title: "Hello" },
+    });
 
-    expect(capturedName).toBe('app_open');
+    expect(capturedName).toBe("app_open");
     expect(capturedInput).toEqual({
-      app_id: 'my-app',
-      preview: { title: 'Hello' },
+      app_id: "my-app",
+      preview: { title: "Hello" },
     });
   });
 
-  test('returns informational message when resolver is undefined', async () => {
-    const result = await openAppViaSurface('app-1', undefined);
+  test("returns informational message when resolver is undefined", async () => {
+    const result = await openAppViaSurface("app-1", undefined);
     expect(result).toBe(
-      'App created but could not be opened (no connected client). Use app_open to open it manually.',
+      "App created but could not be opened (no connected client). Use app_open to open it manually.",
     );
   });
 
-  test('returns fallback text when resolver throws', async () => {
+  test("returns fallback text when resolver throws", async () => {
     const resolver: ProxyResolver = async () => {
-      throw new Error('connection lost');
+      throw new Error("connection lost");
     };
 
-    const result = await openAppViaSurface('app-1', resolver);
-    expect(result).toBe('Failed to auto-open app. Use app_open to open it manually.');
+    const result = await openAppViaSurface("app-1", resolver);
+    expect(result).toBe(
+      "Failed to auto-open app. Use app_open to open it manually.",
+    );
   });
 
-  test('omits extraInput fields when not provided', async () => {
+  test("omits extraInput fields when not provided", async () => {
     let capturedInput: Record<string, unknown> | undefined;
 
     const resolver: ProxyResolver = async (_name, input) => {
       capturedInput = input;
-      return { content: 'ok', isError: false };
+      return { content: "ok", isError: false };
     };
 
-    await openAppViaSurface('app-2', resolver);
-    expect(capturedInput).toEqual({ app_id: 'app-2' });
+    await openAppViaSurface("app-2", resolver);
+    expect(capturedInput).toEqual({ app_id: "app-2" });
   });
 });