vellum 0.0.16 → 0.2.0

package/src/__tests__/workspace-heartbeat-service.test.ts

@@ -0,0 +1,347 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import {
+  WorkspaceGitService,
+  _resetGitServiceRegistry,
+} from '../workspace/git-service.js';
+import {
+  HeartbeatService,
+  _resetHeartbeatState,
+} from '../workspace/heartbeat-service.js';
+
+describe('HeartbeatService', () => {
+  let testDir: string;
+  let service: WorkspaceGitService;
+  let services: Map<string, WorkspaceGitService>;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `vellum-heartbeat-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(testDir, { recursive: true });
+    _resetGitServiceRegistry();
+    _resetHeartbeatState();
+
+    service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    services = new Map();
+    services.set(testDir, service);
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('heartbeat check with age threshold', () => {
+    test('does not commit when workspace is clean', async () => {
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 0, // Immediate
+        fileThreshold: 1,
+        getServices: () => services,
+      });
+
+      const result = await heartbeat.check();
+
+      expect(result.checked).toBe(1);
+      expect(result.committed).toBe(0);
+      expect(result.skipped).toBe(1);
+    });
+
+    test('does not commit when changes are below age and file thresholds', async () => {
+      writeFileSync(join(testDir, 'file.txt'), 'content');
+
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 10 * 60 * 1000, // 10 minutes
+        fileThreshold: 100,
+        getServices: () => services,
+      });
+
+      const result = await heartbeat.check();
+
+      expect(result.checked).toBe(1);
+      expect(result.committed).toBe(0);
+      expect(result.skipped).toBe(1);
+    });
+
+    test('commits when changes exceed age threshold', async () => {
+      writeFileSync(join(testDir, 'file.txt'), 'content');
+
+      let currentTime = 1000000;
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 5 * 60 * 1000, // 5 minutes
+        fileThreshold: 100,
+        getServices: () => services,
+        now: () => currentTime,
+      });
+
+      // First check: records dirty time but doesn't commit (too recent)
+      const firstResult = await heartbeat.check();
+      expect(firstResult.committed).toBe(0);
+
+      // Advance time past threshold
+      currentTime += 6 * 60 * 1000; // 6 minutes later
+
+      const secondResult = await heartbeat.check();
+      expect(secondResult.committed).toBe(1);
+
+      // Verify commit message
+      const commitMsg = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+        cwd: testDir,
+        encoding: 'utf-8',
+      });
+      expect(commitMsg).toContain('auto-commit');
+      expect(commitMsg).toContain('heartbeat');
+      expect(commitMsg).toContain('safety net');
+    });
+
+    test('commits when file count exceeds threshold', async () => {
+      // Create enough files to exceed the threshold
+      for (let i = 0; i < 25; i++) {
+        writeFileSync(join(testDir, `file${i}.txt`), `content ${i}`);
+      }
+
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 10 * 60 * 1000, // 10 minutes (not yet)
+        fileThreshold: 20,
+        getServices: () => services,
+      });
+
+      const result = await heartbeat.check();
+
+      expect(result.committed).toBe(1);
+
+      // Verify commit message mentions file count
+      const commitMsg = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+        cwd: testDir,
+        encoding: 'utf-8',
+      });
+      expect(commitMsg).toContain('25 files changed');
+    });
+  });
+
+  describe('normal operation does not create spurious commits', () => {
+    test('clean workspace produces no heartbeat commits', async () => {
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 0,
+        fileThreshold: 1,
+        getServices: () => services,
+      });
+
+      // Run check multiple times on clean workspace
+      for (let i = 0; i < 5; i++) {
+        const result = await heartbeat.check();
+        expect(result.committed).toBe(0);
+      }
+
+      // Only the initial commit should exist
+      const commitCount = execFileSync('git', ['rev-list', '--count', 'HEAD'], {
+        cwd: testDir,
+        encoding: 'utf-8',
+      }).trim();
+      expect(parseInt(commitCount, 10)).toBe(1);
+    });
+
+    test('changes below both thresholds do not trigger heartbeat commit', async () => {
+      // Create a small number of files (below file threshold)
+      writeFileSync(join(testDir, 'small-change.txt'), 'content');
+
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 10 * 60 * 1000, // 10 minutes
+        fileThreshold: 100, // Very high
+        getServices: () => services,
+      });
+
+      const result = await heartbeat.check();
+      expect(result.committed).toBe(0);
+      expect(result.skipped).toBe(1);
+    });
+
+    test('does not double-commit after turn-boundary commit clears changes', async () => {
+      writeFileSync(join(testDir, 'file.txt'), 'content');
+
+      let currentTime = 1000000;
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 5 * 60 * 1000,
+        fileThreshold: 100,
+        getServices: () => services,
+        now: () => currentTime,
+      });
+
+      // First check: records dirty state
+      await heartbeat.check();
+
+      // Simulate a turn-boundary commit that clears the changes
+      await service.commitChanges('Turn-boundary commit');
+
+      // Advance time past the threshold
+      currentTime += 6 * 60 * 1000;
+
+      // Heartbeat should see clean workspace and skip
+      const result = await heartbeat.check();
+      expect(result.committed).toBe(0);
+      expect(result.skipped).toBe(1);
+    });
+  });
+
+  describe('shutdown commits', () => {
+    test('commits pending changes on shutdown', async () => {
+      writeFileSync(join(testDir, 'unsaved.txt'), 'uncommitted content');
+
+      const heartbeat = new HeartbeatService({
+        getServices: () => services,
+      });
+
+      const result = await heartbeat.commitAllPending();
+
+      expect(result.checked).toBe(1);
+      expect(result.committed).toBe(1);
+
+      // Verify commit message
+      const commitMsg = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+        cwd: testDir,
+        encoding: 'utf-8',
+      });
+      expect(commitMsg).toContain('auto-commit');
+      expect(commitMsg).toContain('shutdown');
+      expect(commitMsg).toContain('safety net');
+    });
+
+    test('does not commit on shutdown when workspace is clean', async () => {
+      const heartbeat = new HeartbeatService({
+        getServices: () => services,
+      });
+
+      const result = await heartbeat.commitAllPending();
+
+      expect(result.checked).toBe(1);
+      expect(result.committed).toBe(0);
+      expect(result.skipped).toBe(1);
+    });
+
+    test('shutdown commits multiple workspaces', async () => {
+      const testDir2 = join(tmpdir(), `vellum-heartbeat-test2-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(testDir2, { recursive: true });
+      const service2 = new WorkspaceGitService(testDir2);
+      await service2.ensureInitialized();
+      services.set(testDir2, service2);
+
+      writeFileSync(join(testDir, 'file1.txt'), 'content1');
+      writeFileSync(join(testDir2, 'file2.txt'), 'content2');
+
+      const heartbeat = new HeartbeatService({
+        getServices: () => services,
+      });
+
+      const result = await heartbeat.commitAllPending();
+
+      expect(result.checked).toBe(2);
+      expect(result.committed).toBe(2);
+
+      // Clean up second test dir
+      rmSync(testDir2, { recursive: true, force: true });
+    });
+  });
+
+  describe('uninitialized workspaces', () => {
+    test('skips uninitialized workspaces', async () => {
+      const uninitDir = join(tmpdir(), `vellum-uninit-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(uninitDir, { recursive: true });
+
+      const uninitService = new WorkspaceGitService(uninitDir);
+      const mixedServices = new Map<string, WorkspaceGitService>();
+      mixedServices.set(uninitDir, uninitService);
+      mixedServices.set(testDir, service);
+
+      writeFileSync(join(testDir, 'file.txt'), 'content');
+
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 0,
+        fileThreshold: 1,
+        getServices: () => mixedServices,
+        now: () => Date.now(),
+      });
+
+      // First check to register dirty state, then immediate second check
+      await heartbeat.check();
+
+      const result = await heartbeat.check();
+      // Only initialized workspace should be checked
+      // The first check committed the file, so the second check sees it clean
+      expect(result.checked).toBe(1);
+
+      rmSync(uninitDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('threshold behavior', () => {
+    test('resets dirty tracking after successful commit', async () => {
+      let currentTime = 1000000;
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 5 * 60 * 1000,
+        fileThreshold: 100,
+        getServices: () => services,
+        now: () => currentTime,
+      });
+
+      // Create changes and register dirty state
+      writeFileSync(join(testDir, 'file1.txt'), 'content');
+      await heartbeat.check(); // Records first-seen time
+
+      // Advance past threshold and commit
+      currentTime += 6 * 60 * 1000;
+      const firstResult = await heartbeat.check();
+      expect(firstResult.committed).toBe(1);
+
+      // Create new changes after the commit
+      writeFileSync(join(testDir, 'file2.txt'), 'more content');
+
+      // Check again immediately -- should not commit (dirty timer was reset)
+      const secondResult = await heartbeat.check();
+      expect(secondResult.committed).toBe(0);
+
+      // Advance past threshold again
+      currentTime += 6 * 60 * 1000;
+      const thirdResult = await heartbeat.check();
+      expect(thirdResult.committed).toBe(1);
+    });
+
+    test('commit message includes trigger metadata', async () => {
+      writeFileSync(join(testDir, 'file.txt'), 'content');
+
+      const heartbeat = new HeartbeatService({
+        ageThresholdMs: 0,
+        fileThreshold: 1,
+        getServices: () => services,
+      });
+
+      // Two checks: first registers, second commits (age 0 means immediate on re-check)
+      await heartbeat.check();
+      await heartbeat.check();
+
+      const commitMsg = execFileSync('git', ['log', '-1', '--pretty=%B'], {
+        cwd: testDir,
+        encoding: 'utf-8',
+      });
+      expect(commitMsg).toContain('trigger: "heartbeat"');
+    });
+  });
+
+  describe('start and stop', () => {
+    test('start and stop are idempotent', async () => {
+      const heartbeat = new HeartbeatService({
+        intervalMs: 60000,
+        getServices: () => services,
+      });
+
+      // Should not throw
+      heartbeat.start();
+      heartbeat.start(); // Idempotent
+      await heartbeat.stop();
+      await heartbeat.stop(); // Idempotent
+    });
+  });
+});

package/src/__tests__/workspace-lifecycle.test.ts

@@ -0,0 +1,292 @@
+/**
+ * Integration-style test that exercises the full git workspace lifecycle:
+ *   lazy init → turn-boundary commits → heartbeat safety net → commit history verification.
+ *
+ * This test wires together WorkspaceGitService, commitTurnChanges, and HeartbeatService
+ * in the same flow a real daemon session would follow.
+ */
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import {
+  WorkspaceGitService,
+  getWorkspaceGitService,
+  _resetGitServiceRegistry,
+} from '../workspace/git-service.js';
+import { commitTurnChanges } from '../workspace/turn-commit.js';
+import {
+  HeartbeatService,
+  _resetHeartbeatState,
+} from '../workspace/heartbeat-service.js';
+
+describe('Workspace git lifecycle (integration)', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(
+      tmpdir(),
+      `vellum-lifecycle-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(testDir, { recursive: true });
+    _resetGitServiceRegistry();
+    _resetHeartbeatState();
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  // Build a clean git env: strip all GIT_* env vars that CI runners
+  // inject, then set GIT_CEILING_DIRECTORIES to isolate test repos.
+  function gitEnv(cwd: string): Record<string, string> {
+    const env: Record<string, string> = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined && !key.startsWith('GIT_')) {
+        env[key] = value;
+      }
+    }
+    env.GIT_CEILING_DIRECTORIES = cwd;
+    return env;
+  }
+
+  // Helper to read git log output
+  function gitLog(cwd: string, format = '--oneline'): string {
+    return execFileSync('git', ['log', format], { cwd, encoding: 'utf-8', env: gitEnv(cwd) }).trim();
+  }
+
+  function commitCount(cwd: string): number {
+    return parseInt(
+      execFileSync('git', ['rev-list', '--count', 'HEAD'], { cwd, encoding: 'utf-8', env: gitEnv(cwd) }).trim(),
+      10,
+    );
+  }
+
+  function lastCommitMessage(cwd: string): string {
+    return execFileSync('git', ['log', '-1', '--pretty=%B'], { cwd, encoding: 'utf-8', env: gitEnv(cwd) }).trim();
+  }
+
+  function lastCommitFiles(cwd: string): string[] {
+    return execFileSync('git', ['diff', '--name-only', 'HEAD~1', 'HEAD'], {
+      cwd,
+      encoding: 'utf-8',
+      env: gitEnv(cwd),
+    })
+      .trim()
+      .split('\n')
+      .filter(Boolean);
+  }
+
+  test('full lifecycle: init → turns → heartbeat → history', async () => {
+    const sessionId = 'sess_lifecycle_test';
+
+    // ----------------------------------------------------------------
+    // Step 1: Lazy initialization — workspace starts without a git repo
+    // ----------------------------------------------------------------
+    expect(existsSync(join(testDir, '.git'))).toBe(false);
+
+    // Pre-populate workspace with files (simulates existing workspace)
+    writeFileSync(join(testDir, 'README.md'), '# My Project');
+    writeFileSync(join(testDir, 'config.json'), '{"version": 1}');
+
+    // Getting the service via the singleton registry is how session.ts does it
+    const service = getWorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    // Verify lazy init created the repo and the initial commit
+    expect(existsSync(join(testDir, '.git'))).toBe(true);
+    expect(commitCount(testDir)).toBe(1);
+    expect(lastCommitMessage(testDir)).toContain('Initial commit: migrated existing workspace');
+
+    // ----------------------------------------------------------------
+    // Step 2: Turn 1 — assistant edits files, turn-boundary commit fires
+    // ----------------------------------------------------------------
+    writeFileSync(join(testDir, 'hello.ts'), 'export const greeting = "hello";');
+    writeFileSync(join(testDir, 'config.json'), '{"version": 2}');
+
+    await commitTurnChanges(testDir, sessionId, 1);
+
+    expect(commitCount(testDir)).toBe(2);
+    const turn1Msg = lastCommitMessage(testDir);
+    expect(turn1Msg).toContain('Turn:');
+    expect(turn1Msg).toContain('Session: sess_lifecycle_test');
+    expect(turn1Msg).toContain('Turn: 1');
+    expect(turn1Msg).toContain('Files: 2 changed');
+    expect(turn1Msg).toMatch(/Timestamp: \d{4}-\d{2}-\d{2}T/);
+
+    const turn1Files = lastCommitFiles(testDir);
+    expect(turn1Files).toContain('hello.ts');
+    expect(turn1Files).toContain('config.json');
+
+    // ----------------------------------------------------------------
+    // Step 3: Turn 2 — more edits
+    // ----------------------------------------------------------------
+    mkdirSync(join(testDir, 'src'), { recursive: true });
+    writeFileSync(join(testDir, 'src', 'index.ts'), 'console.log("hello");');
+
+    await commitTurnChanges(testDir, sessionId, 2);
+
+    expect(commitCount(testDir)).toBe(3);
+    const turn2Msg = lastCommitMessage(testDir);
+    expect(turn2Msg).toContain('Turn: 2');
+    expect(turn2Msg).toContain('Files: 1 changed');
+
+    // ----------------------------------------------------------------
+    // Step 4: Turn 3 — no changes (should NOT create a commit)
+    // ----------------------------------------------------------------
+    await commitTurnChanges(testDir, sessionId, 3);
+    expect(commitCount(testDir)).toBe(3); // Still 3
+
+    // ----------------------------------------------------------------
+    // Step 5: Heartbeat safety net — simulate uncommitted changes
+    //         that linger past the age threshold
+    // ----------------------------------------------------------------
+    writeFileSync(join(testDir, 'background-output.log.txt'), 'background process output');
+
+    // Build a services map the way the heartbeat does at runtime
+    const services = new Map<string, WorkspaceGitService>();
+    services.set(testDir, service);
+
+    let fakeTime = 2_000_000;
+    const heartbeat = new HeartbeatService({
+      ageThresholdMs: 5 * 60 * 1000,
+      fileThreshold: 100,
+      getServices: () => services,
+      now: () => fakeTime,
+    });
+
+    // First heartbeat: records the dirty timestamp
+    const firstCheck = await heartbeat.check();
+    expect(firstCheck.committed).toBe(0);
+    expect(firstCheck.skipped).toBe(1); // Below threshold
+
+    // Advance time past 5-minute threshold
+    fakeTime += 6 * 60 * 1000;
+
+    const secondCheck = await heartbeat.check();
+    expect(secondCheck.committed).toBe(1);
+    expect(commitCount(testDir)).toBe(4);
+
+    const heartbeatMsg = lastCommitMessage(testDir);
+    expect(heartbeatMsg).toContain('auto-commit');
+    expect(heartbeatMsg).toContain('heartbeat');
+    expect(heartbeatMsg).toContain('safety net');
+
+    // ----------------------------------------------------------------
+    // Step 6: Verify full commit history has correct ordering/metadata
+    // ----------------------------------------------------------------
+    const fullLog = gitLog(testDir, '--oneline');
+    const lines = fullLog.split('\n');
+    expect(lines.length).toBe(4);
+
+    // Most recent first
+    expect(lines[0]).toContain('auto-commit');
+    expect(lines[1]).toContain('Turn:');
+    expect(lines[2]).toContain('Turn:');
+    expect(lines[3]).toContain('Initial commit');
+
+    // ----------------------------------------------------------------
+    // Step 7: Shutdown commit — one more file, then graceful shutdown
+    // ----------------------------------------------------------------
+    writeFileSync(join(testDir, 'unsaved-work.txt'), 'important unsaved data');
+
+    const shutdownResult = await heartbeat.commitAllPending();
+    expect(shutdownResult.committed).toBe(1);
+    expect(commitCount(testDir)).toBe(5);
+    expect(lastCommitMessage(testDir)).toContain('shutdown');
+  });
+
+  test('workspace recovers from corrupted .git directory', async () => {
+    // Initialize a real repo, then corrupt it by removing HEAD.
+    // This is more realistic than an empty .git dir (which behaves
+    // differently across git versions and CI environments).
+    execFileSync('git', ['init', '-b', 'main'], {
+      cwd: testDir,
+      encoding: 'utf-8',
+      env: gitEnv(testDir),
+    });
+    rmSync(join(testDir, '.git', 'HEAD'));
+
+    const service = new WorkspaceGitService(testDir);
+
+    // The key behavior: ensureInitialized must NOT throw on a corrupted repo.
+    await service.ensureInitialized();
+
+    // Service reports as initialized and the repo is functional.
+    // We only assert isInitialized() here because on CI runners the
+    // corruption recovery path can't fully isolate from the parent
+    // checkout repo (git env vars and configs leak through despite
+    // cleanGitEnv), causing git status and log helpers to read from
+    // the wrong repo.
+    expect(service.isInitialized()).toBe(true);
+  });
+
+  test('concurrent turn commits and heartbeats do not conflict', async () => {
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    // Simulate concurrent turn commits and heartbeat checks
+    const services = new Map<string, WorkspaceGitService>();
+    services.set(testDir, service);
+
+    const heartbeat = new HeartbeatService({
+      ageThresholdMs: 0,
+      fileThreshold: 1,
+      getServices: () => services,
+    });
+
+    // Create files and fire turn commits + heartbeat checks concurrently
+    const operations: Promise<unknown>[] = [];
+    for (let i = 0; i < 5; i++) {
+      writeFileSync(join(testDir, `concurrent-${i}.txt`), `content ${i}`);
+      operations.push(commitTurnChanges(testDir, 'sess_concurrent', i + 1));
+      operations.push(heartbeat.check());
+    }
+
+    // None of these should throw (mutex serialization prevents conflicts)
+    await Promise.all(operations);
+
+    // Verify the repo is in a consistent state
+    const status = await service.getStatus();
+    expect(status.clean).toBe(true);
+  });
+
+  test('fire-and-forget pattern does not lose commits', async () => {
+    const service = new WorkspaceGitService(testDir);
+    await service.ensureInitialized();
+
+    // Simulate the session.ts fire-and-forget pattern:
+    // `void commitTurnChanges(...)` -- the void discards the promise
+    writeFileSync(join(testDir, 'fire-forget-1.txt'), 'content 1');
+    const p1 = commitTurnChanges(testDir, 'sess_ff', 1);
+
+    writeFileSync(join(testDir, 'fire-forget-2.txt'), 'content 2');
+    const p2 = commitTurnChanges(testDir, 'sess_ff', 2);
+
+    // Even though session.ts doesn't await these, they should eventually complete
+    await Promise.all([p1, p2]);
+
+    // All files should be committed (no data loss).
+    // The first commit may absorb both files, so the second sees a clean
+    // workspace and correctly skips rather than creating an empty commit.
+    const count = commitCount(testDir);
+    expect(count).toBeGreaterThanOrEqual(2); // initial + at least 1 turn commit
+
+    // Verify no file changes are lost
+    const status = await service.getStatus();
+    expect(status.clean).toBe(true);
+  });
+
+  test('getWorkspaceGitService returns same instance across turn commits and heartbeat', async () => {
+    // Verify the singleton registry is coherent across all modules
+    const fromTurnCommitPath = getWorkspaceGitService(testDir);
+    const fromHeartbeatPath = getWorkspaceGitService(testDir);
+    const fromDirectCall = getWorkspaceGitService(testDir);
+
+    expect(fromTurnCommitPath).toBe(fromHeartbeatPath);
+    expect(fromHeartbeatPath).toBe(fromDirectCall);
+  });
+});

package/src/agent/attachments.ts

@@ -0,0 +1,35 @@
+import type { ContentBlock } from "../providers/types.js";
+
+export interface MessageAttachmentInput {
+  id?: string;
+  filename: string;
+  mimeType: string;
+  data: string;
+  extractedText?: string;
+}
+
+export function attachmentsToContentBlocks(attachments: MessageAttachmentInput[]): ContentBlock[] {
+  return attachments.map((attachment) => {
+    if (attachment.mimeType.toLowerCase().startsWith("image/")) {
+      return {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: attachment.mimeType,
+          data: attachment.data,
+        },
+      } as ContentBlock;
+    }
+
+    return {
+      type: "file",
+      source: {
+        type: "base64",
+        media_type: attachment.mimeType,
+        data: attachment.data,
+        filename: attachment.filename,
+      },
+      extracted_text: attachment.extractedText,
+    } as ContentBlock;
+  });
+}