@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/core/sync.test.ts

@@ -0,0 +1,354 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execSync } from 'child_process';
+
+/**
+ * Tests for the sync core logic.
+ * We test the git helper functions and sync state management
+ * by operating on a real temp git repo.
+ *
+ * Note: The sync API route (/api/sync) reads ~/.mindos/config.json directly,
+ * making it hard to unit test without modifying global state.
+ * These tests cover the underlying git operations instead.
+ */
+
+let tmpDir: string;
+let mindRoot: string;
+
+function setup() {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-sync-test-'));
+  mindRoot = path.join(tmpDir, 'mind');
+  fs.mkdirSync(mindRoot, { recursive: true });
+  execSync('git init', { cwd: mindRoot, stdio: 'pipe' });
+  execSync('git checkout -b main', { cwd: mindRoot, stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { cwd: mindRoot, stdio: 'pipe' });
+  execSync('git config user.name "Test"', { cwd: mindRoot, stdio: 'pipe' });
+  fs.writeFileSync(path.join(mindRoot, 'README.md'), '# test\n');
+  execSync('git add -A && git commit -m "init"', { cwd: mindRoot, stdio: 'pipe' });
+}
+
+function cleanup() {
+  if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+}
+
+describe('sync: git operations', () => {
+  beforeEach(setup);
+  afterEach(cleanup);
+
+  it('detects git repo correctly', () => {
+    expect(fs.existsSync(path.join(mindRoot, '.git'))).toBe(true);
+    expect(fs.existsSync(path.join(tmpDir, '.git'))).toBe(false);
+  });
+
+  it('reads branch name', () => {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+    expect(branch).toBe('main');
+  });
+
+  it('detects no uncommitted changes after clean commit', () => {
+    const status = execSync('git status --porcelain', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+    expect(status).toBe('');
+  });
+
+  it('detects uncommitted changes', () => {
+    fs.writeFileSync(path.join(mindRoot, 'new-file.md'), 'hello\n');
+    const status = execSync('git status --porcelain', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+    expect(status).toContain('new-file.md');
+  });
+
+  it('auto-commit stages and commits changes', () => {
+    fs.writeFileSync(path.join(mindRoot, 'auto-test.md'), 'auto content\n');
+    execSync('git add -A', { cwd: mindRoot, stdio: 'pipe' });
+    const status = execSync('git status --porcelain', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+    expect(status).not.toBe('');
+
+    const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    execSync(`git commit -m "auto-sync: ${timestamp}"`, { cwd: mindRoot, stdio: 'pipe' });
+
+    const afterStatus = execSync('git status --porcelain', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+    expect(afterStatus).toBe('');
+
+    const log = execSync('git log --oneline -1', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+    expect(log).toContain('auto-sync:');
+  });
+
+  it('handles already-clean repo gracefully (no empty commits)', () => {
+    const statusBefore = execSync('git status --porcelain', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+    expect(statusBefore).toBe('');
+
+    // Count commits before
+    const countBefore = execSync('git rev-list --count HEAD', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+
+    // Simulate autoCommitAndPush skipping when no changes
+    execSync('git add -A', { cwd: mindRoot, stdio: 'pipe' });
+    const status = execSync('git status --porcelain', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+    // Should be empty — no commit needed
+    expect(status).toBe('');
+
+    const countAfter = execSync('git rev-list --count HEAD', {
+      cwd: mindRoot, encoding: 'utf-8', stdio: 'pipe',
+    }).trim();
+    expect(countAfter).toBe(countBefore);
+  });
+});
+
+describe('sync: conflict file creation', () => {
+  beforeEach(setup);
+  afterEach(cleanup);
+
+  it('creates .sync-conflict file with theirs content', () => {
+    // Simulate what autoPull conflict resolution does
+    const file = 'notes.md';
+    const localContent = 'local version\n';
+    const remoteContent = 'remote version\n';
+
+    fs.writeFileSync(path.join(mindRoot, file), localContent);
+    fs.writeFileSync(path.join(mindRoot, file + '.sync-conflict'), remoteContent);
+
+    expect(fs.readFileSync(path.join(mindRoot, file), 'utf-8')).toBe(localContent);
+    expect(fs.readFileSync(path.join(mindRoot, file + '.sync-conflict'), 'utf-8')).toBe(remoteContent);
+  });
+});
+
+describe('sync: state file management', () => {
+  beforeEach(setup);
+  afterEach(cleanup);
+
+  it('reads and writes sync state', () => {
+    const statePath = path.join(tmpDir, 'sync-state.json');
+
+    // Initially no state file
+    expect(fs.existsSync(statePath)).toBe(false);
+
+    // Write state
+    const state = {
+      lastSync: new Date().toISOString(),
+      lastPull: new Date().toISOString(),
+      conflicts: [],
+      lastError: null,
+    };
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n');
+
+    // Read back
+    const loaded = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+    expect(loaded.lastSync).toBe(state.lastSync);
+    expect(loaded.lastPull).toBe(state.lastPull);
+    expect(loaded.conflicts).toEqual([]);
+    expect(loaded.lastError).toBeNull();
+  });
+
+  it('stores conflict records correctly', () => {
+    const statePath = path.join(tmpDir, 'sync-state.json');
+    const conflicts = [
+      { file: 'notes/todo.md', time: '2026-03-14T10:30:00.000Z' },
+      { file: 'journal/2026-03.md', time: '2026-03-14T10:30:00.000Z' },
+    ];
+    const state = { lastSync: new Date().toISOString(), conflicts };
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n');
+
+    const loaded = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+    expect(loaded.conflicts).toHaveLength(2);
+    expect(loaded.conflicts[0].file).toBe('notes/todo.md');
+    expect(loaded.conflicts[1].file).toBe('journal/2026-03.md');
+  });
+});
+
+describe('sync: .gitignore auto-creation (O5)', () => {
+  beforeEach(setup);
+  afterEach(cleanup);
+
+  it('creates .gitignore with expected entries when file does not exist', () => {
+    const gitignorePath = path.join(mindRoot, '.gitignore');
+
+    // Initially setup() does NOT create .gitignore
+    expect(fs.existsSync(gitignorePath)).toBe(false);
+
+    // Simulate what initSync does: create .gitignore if missing
+    if (!fs.existsSync(gitignorePath)) {
+      fs.writeFileSync(gitignorePath, [
+        '# MindOS auto-generated',
+        '.DS_Store',
+        'Thumbs.db',
+        '*.tmp',
+        '*.bak',
+        '*.swp',
+        '*.sync-conflict',
+        'node_modules/',
+        '.obsidian/',
+        '',
+      ].join('\n'), 'utf-8');
+    }
+
+    expect(fs.existsSync(gitignorePath)).toBe(true);
+    const content = fs.readFileSync(gitignorePath, 'utf-8');
+    expect(content).toContain('.DS_Store');
+    expect(content).toContain('*.sync-conflict');
+    expect(content).toContain('node_modules/');
+    expect(content).toContain('.obsidian/');
+  });
+
+  it('does not overwrite existing .gitignore', () => {
+    const gitignorePath = path.join(mindRoot, '.gitignore');
+    const customContent = '# Custom gitignore\n*.log\n';
+    fs.writeFileSync(gitignorePath, customContent);
+
+    // Simulate initSync check: skip if exists
+    if (!fs.existsSync(gitignorePath)) {
+      fs.writeFileSync(gitignorePath, '# MindOS auto-generated\n');
+    }
+
+    expect(fs.readFileSync(gitignorePath, 'utf-8')).toBe(customContent);
+  });
+});
+
+describe('sync: daemon idempotency (O1)', () => {
+  it('idempotent guard prevents double activation', () => {
+    // Simulate the idempotent guard logic from startSyncDaemon
+    let activeWatcher: unknown = null;
+    let callCount = 0;
+
+    function startDaemon() {
+      if (activeWatcher) return null; // idempotent guard
+      callCount++;
+      activeWatcher = { close() { activeWatcher = null; } };
+      return activeWatcher;
+    }
+
+    // First call succeeds
+    const result1 = startDaemon();
+    expect(result1).not.toBeNull();
+    expect(callCount).toBe(1);
+
+    // Second call returns null (already running)
+    const result2 = startDaemon();
+    expect(result2).toBeNull();
+    expect(callCount).toBe(1); // not incremented
+  });
+});
+
+describe('sync: manualSync throws instead of process.exit (bonus)', () => {
+  it('throws error for non-git directory', () => {
+    // Simulate the manualSync logic: throw instead of process.exit
+    function manualSync(mindRoot: string | null) {
+      if (!mindRoot || !fs.existsSync(path.join(mindRoot, '.git'))) {
+        throw new Error('Not a git repository. Run `mindos sync init` first.');
+      }
+    }
+
+    // Should throw for a directory without .git
+    expect(() => manualSync(os.tmpdir())).toThrow('Not a git repository');
+    expect(() => manualSync(null)).toThrow('Not a git repository');
+  });
+});
+
+describe('sync: config management', () => {
+  beforeEach(setup);
+  afterEach(cleanup);
+
+  it('merges sync config into existing config', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const existing = {
+      mindRoot,
+      port: 3456,
+      authToken: 'test',
+    };
+    fs.writeFileSync(configPath, JSON.stringify(existing, null, 2));
+
+    // Add sync config
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    config.sync = {
+      enabled: true,
+      provider: 'git',
+      remote: 'origin',
+      branch: 'main',
+      autoCommitInterval: 30,
+      autoPullInterval: 300,
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+    // Verify
+    const reloaded = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    expect(reloaded.mindRoot).toBe(mindRoot);
+    expect(reloaded.authToken).toBe('test');
+    expect(reloaded.sync.enabled).toBe(true);
+    expect(reloaded.sync.autoCommitInterval).toBe(30);
+    expect(reloaded.sync.autoPullInterval).toBe(300);
+  });
+
+  it('toggles sync enabled flag without losing other config', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const config = {
+      mindRoot,
+      port: 3456,
+      sync: { enabled: true, provider: 'git', autoCommitInterval: 30, autoPullInterval: 300 },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+    // Disable
+    const loaded = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    loaded.sync.enabled = false;
+    fs.writeFileSync(configPath, JSON.stringify(loaded, null, 2));
+
+    const reloaded = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    expect(reloaded.sync.enabled).toBe(false);
+    expect(reloaded.sync.provider).toBe('git');
+    expect(reloaded.mindRoot).toBe(mindRoot);
+  });
+});
+
+describe('sync: path traversal protection', () => {
+  beforeEach(setup);
+  afterEach(cleanup);
+
+  /**
+   * Helper to test if a file path is safely within mindRoot
+   * (mirrors the isPathWithinMindRoot function in sync/route.ts)
+   */
+  function isPathWithinMindRoot(mindRootDir: string, filePath: string): boolean {
+    const normalizedPath = path.resolve(mindRootDir, filePath);
+    return normalizedPath.startsWith(mindRootDir + '/') || normalizedPath === mindRootDir;
+  }
+
+  it('allows normal relative paths', () => {
+    expect(isPathWithinMindRoot(mindRoot, 'notes/todo.md')).toBe(true);
+    expect(isPathWithinMindRoot(mindRoot, 'README.md')).toBe(true);
+    expect(isPathWithinMindRoot(mindRoot, 'deep/nested/file.md')).toBe(true);
+  });
+
+  it('blocks path traversal with ../', () => {
+    expect(isPathWithinMindRoot(mindRoot, '../etc/passwd')).toBe(false);
+    expect(isPathWithinMindRoot(mindRoot, '../../etc/passwd')).toBe(false);
+    expect(isPathWithinMindRoot(mindRoot, 'notes/../../../etc/passwd')).toBe(false);
+  });
+
+  it('blocks absolute paths outside mindRoot', () => {
+    expect(isPathWithinMindRoot(mindRoot, '/etc/passwd')).toBe(false);
+    expect(isPathWithinMindRoot(mindRoot, '/tmp/malicious')).toBe(false);
+  });
+
+  it('allows paths that start with .. but resolve within mindRoot', () => {
+    // e.g., notes/../README.md resolves to mindRoot/README.md
+    expect(isPathWithinMindRoot(mindRoot, 'notes/../README.md')).toBe(true);
+    expect(isPathWithinMindRoot(mindRoot, './notes/../notes/todo.md')).toBe(true);
+  });
+});

package/_standalone/__tests__/core/tools.test.ts

@@ -0,0 +1,339 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { seedFile } from '../setup';
+import { knowledgeBaseTools, truncate } from '@/lib/agent/tools';
+
+// knowledgeBaseTools is an array of AgentTool objects.
+// Each tool: { name, execute: (toolCallId, params, signal?) => AgentToolResult }
+// AgentToolResult: { content: [{ type: 'text', text }], details }
+
+/** Find a tool by name from the array */
+function getTool(name: string) {
+  const tool = knowledgeBaseTools.find(t => t.name === name);
+  if (!tool) throw new Error(`Tool "${name}" not found. Available: ${knowledgeBaseTools.map(t => t.name).join(', ')}`);
+  return tool;
+}
+
+/** Call a tool and extract the text result */
+async function callTool(name: string, params: Record<string, unknown>): Promise<string> {
+  const tool = getTool(name);
+  const result = await tool.execute!('test-call-id', params);
+  // AgentToolResult has content: [{ type: 'text', text }]
+  const textPart = result.content?.find((c: any) => c.type === 'text');
+  return textPart?.text ?? JSON.stringify(result);
+}
+
+// ---------------------------------------------------------------------------
+// truncate (exported utility)
+// ---------------------------------------------------------------------------
+
+describe('truncate', () => {
+  it('returns short content unchanged', () => {
+    expect(truncate('hello')).toBe('hello');
+  });
+
+  it('returns content at exact limit unchanged', () => {
+    const content = 'a'.repeat(20_000);
+    expect(truncate(content)).toBe(content);
+  });
+
+  it('truncates content exceeding limit', () => {
+    const content = 'a'.repeat(25_000);
+    const result = truncate(content);
+    expect(result.length).toBeLessThan(content.length);
+    expect(result).toContain('[...truncated');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// list_files tool
+// ---------------------------------------------------------------------------
+
+describe('tools: list_files', () => {
+  beforeEach(() => {
+    seedFile('README.md', '# Root README');
+    seedFile('Profile/Identity.md', '# Identity');
+    seedFile('Profile/Goals.md', '# Goals');
+    seedFile('Projects/Products/ProductA.md', '# Product A');
+    seedFile('data.csv', 'a,b,c');
+  });
+
+  it('lists all files with default params', async () => {
+    const result = await callTool('list_files', {});
+    expect(result).toContain('Profile/');
+    expect(result).toContain('Identity.md');
+    expect(result).toContain('Goals.md');
+    expect(result).toContain('README.md'); // System files now included in tree
+    expect(result).toContain('data.csv');
+    expect(result).not.toContain('Error:');
+  });
+
+  it('lists a specific subdirectory', async () => {
+    const result = await callTool('list_files', { path: 'Profile' });
+    expect(result).toContain('Identity.md');
+    expect(result).toContain('Goals.md');
+    expect(result).not.toContain('data.csv');
+  });
+
+  it('respects depth parameter', async () => {
+    const result = await callTool('list_files', { depth: 1 });
+    expect(result).toContain('Profile/');
+    expect(result).toContain('...');
+  });
+
+  it('returns error message for non-existent directory', async () => {
+    const result = await callTool('list_files', { path: 'NonExistent' });
+    expect(result).toContain('Directory not found');
+    expect(result).toContain('NonExistent');
+  });
+
+  it('handles nested subdirectory path', async () => {
+    const result = await callTool('list_files', { path: 'Projects/Products' });
+    expect(result).toContain('ProductA.md');
+  });
+
+  it('returns (empty directory) for dir with no allowed files', async () => {
+    seedFile('EmptyDir/test.txt', 'not allowed');
+    const result = await callTool('list_files', {});
+    expect(result).not.toContain('EmptyDir');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// read_file tool
+// ---------------------------------------------------------------------------
+
+describe('tools: read_file', () => {
+  beforeEach(() => {
+    seedFile('test.md', '# Test file\n\nSome content here.');
+  });
+
+  it('reads an existing file', async () => {
+    const result = await callTool('read_file', { path: 'test.md' });
+    expect(result).toContain('# Test file');
+    expect(result).toContain('Some content here.');
+  });
+
+  it('returns error for non-existent file', async () => {
+    const result = await callTool('read_file', { path: 'does-not-exist.md' });
+    expect(result).toContain('Error:');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// search tool
+// ---------------------------------------------------------------------------
+
+describe('tools: search', () => {
+  beforeEach(() => {
+    seedFile('notes/alpha.md', '# Alpha\n\nUnique keyword xyzzyplugh here.');
+    seedFile('notes/beta.md', '# Beta\n\nSomething else entirely.');
+  });
+
+  it('returns no results for unmatched query', async () => {
+    const result = await callTool('search', { query: 'definitelynotfound99' });
+    expect(result).toBe('No results found.');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// write_file tool
+// ---------------------------------------------------------------------------
+
+describe('tools: write_file', () => {
+  beforeEach(() => {
+    seedFile('existing.md', '# Old content');
+  });
+
+  it('overwrites file content', async () => {
+    const result = await callTool('write_file', { path: 'existing.md', content: '# New content' });
+    expect(result).toContain('File written');
+
+    const read = await callTool('read_file', { path: 'existing.md' });
+    expect(read).toContain('# New content');
+    expect(read).not.toContain('# Old content');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// create_file tool
+// ---------------------------------------------------------------------------
+
+describe('tools: create_file', () => {
+  it('creates a new file', async () => {
+    const result = await callTool('create_file', { path: 'new-note.md', content: '# Hello World' });
+    expect(result).toContain('File created');
+
+    const read = await callTool('read_file', { path: 'new-note.md' });
+    expect(read).toContain('# Hello World');
+  });
+
+  it('creates parent directories automatically', async () => {
+    const result = await callTool('create_file', { path: 'deep/nested/dir/file.md', content: 'nested content' });
+    expect(result).toContain('File created');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// delete_file tool
+// ---------------------------------------------------------------------------
+
+describe('tools: delete_file', () => {
+  beforeEach(() => {
+    seedFile('to-delete.md', '# Delete me');
+  });
+
+  it('moves file to trash instead of permanent delete', async () => {
+    const result = await callTool('delete_file', { path: 'to-delete.md' });
+    expect(result).toContain('Moved to trash');
+
+    const read = await callTool('read_file', { path: 'to-delete.md' });
+    expect(read).toContain('Error:');
+  });
+
+  it('returns error for non-existent file', async () => {
+    const result = await callTool('delete_file', { path: 'ghost.md' });
+    expect(result).toContain('Error:');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// append_to_file tool
+// ---------------------------------------------------------------------------
+
+describe('tools: append_to_file', () => {
+  beforeEach(() => {
+    seedFile('append-target.md', '# Start');
+  });
+
+  it('appends content to file', async () => {
+    const result = await callTool('append_to_file', { path: 'append-target.md', content: '\n## Added Section' });
+    expect(result).toContain('Content appended');
+
+    const read = await callTool('read_file', { path: 'append-target.md' });
+    expect(read).toContain('# Start');
+    expect(read).toContain('## Added Section');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// rename_file tool
+// ---------------------------------------------------------------------------
+
+describe('tools: rename_file', () => {
+  beforeEach(() => {
+    seedFile('old-name.md', '# Rename me');
+  });
+
+  it('renames a file', async () => {
+    const result = await callTool('rename_file', { path: 'old-name.md', new_name: 'new-name.md' });
+    expect(result).toContain('renamed');
+    expect(result).toContain('new-name.md');
+
+    // Old path should be gone
+    const oldRead = await callTool('read_file', { path: 'old-name.md' });
+    expect(oldRead).toContain('Error:');
+
+    // New path should work
+    const newRead = await callTool('read_file', { path: 'new-name.md' });
+    expect(newRead).toContain('# Rename me');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// get_recent tool
+// ---------------------------------------------------------------------------
+
+describe('tools: get_recent', () => {
+  beforeEach(() => {
+    seedFile('a.md', '# A');
+    seedFile('b.md', '# B');
+  });
+
+  it('returns recently modified files', async () => {
+    const result = await callTool('get_recent', {});
+    expect(result).toContain('a.md');
+    expect(result).toContain('b.md');
+  });
+
+  it('respects limit parameter', async () => {
+    const result = await callTool('get_recent', { limit: 1 });
+    // Should only contain one file entry (one line starting with "- ")
+    const lines = result.split('\n').filter(l => l.startsWith('- '));
+    expect(lines).toHaveLength(1);
+  });
+});
+
+describe('web_fetch tool', () => {
+  it('returns formatted text from a URL', async () => {
+    // Mock the global fetch
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      headers: new Headers({ 'content-type': 'text/html' }),
+      text: async () => '<html><head><title>Test Page</title></head><body><h1>Hello</h1><p>This is a <b>test</b>.</p></body></html>',
+    } as any);
+
+    try {
+      const result = await callTool('web_fetch', { url: 'https://example.com' });
+      expect(result).toContain('# Test Page');
+      expect(result).toContain('Source: https://example.com');
+      expect(result).toContain('# Hello');
+      expect(result).toContain('This is a test');
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+
+  it('handles raw text files properly', async () => {
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      headers: new Headers({ 'content-type': 'text/plain' }),
+      text: async () => 'Just plain text.\nWith newlines.',
+    } as any);
+
+    try {
+      const result = await callTool('web_fetch', { url: 'https://example.com/raw.txt' });
+      expect(result).toBe('Just plain text.\nWith newlines.');
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+});
+
+describe('web_search tool', () => {
+  it('returns formatted search results', async () => {
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      text: async () => '<html><body><div class="result__body"><h2 class="result__title"><a href="https://example.com/1">Title 1</a></h2><a class="result__snippet">Snippet 1</a></div><div class="result__body"><h2 class="result__title"><a href="https://example.com/2">Title 2</a></h2><div class="result__snippet">Snippet 2</div></div></body></html>',
+    } as any);
+
+    try {
+      const result = await callTool('web_search', { query: 'test query' });
+      expect(result).toContain('Title 1');
+      expect(result).toContain('https://example.com/1');
+      expect(result).toContain('Snippet 1');
+      expect(result).toContain('Title 2');
+      expect(result).toContain('Snippet 2');
+      expect(result).toContain('Web Search Results for: "test query"');
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+
+  it('handles empty results', async () => {
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      text: async () => '<html><body><div>No results body structure</div></body></html>',
+    } as any);
+
+    try {
+      const result = await callTool('web_search', { query: 'test query' });
+      expect(result).toContain('No web search results found for');
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+});