opensidian 1.0.0

package/tests/core/sync.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { SyncService } from '../../src/core/sync';
+
+describe('SyncService', () => {
+  let syncService: SyncService;
+  const testPort = 19999;
+
+  beforeEach(() => {
+    syncService = new SyncService(testPort);
+  });
+
+  afterEach(() => {
+    syncService.stop();
+  });
+
+  describe('constructor', () => {
+    it('should create sync service with default port', () => {
+      const service = new SyncService();
+      expect(service).toBeDefined();
+    });
+
+    it('should create sync service with custom port', () => {
+      const service = new SyncService(19998);
+      expect(service).toBeDefined();
+    });
+  });
+
+  describe('start/stop', () => {
+    it('should start and stop without errors', () => {
+      expect(() => syncService.start()).not.toThrow();
+      expect(() => syncService.stop()).not.toThrow();
+    });
+
+    it('should not start twice', () => {
+      syncService.start();
+      expect(() => syncService.start()).not.toThrow();
+    });
+  });
+
+  describe('broadcastChange', () => {
+    it('should emit change event', () => {
+      syncService.start();
+      
+      const handler = vi.fn();
+      syncService.on('change', handler);
+
+      syncService.broadcastChange({
+        type: 'note_created',
+        note: { path: 'test.md' },
+      });
+
+      expect(handler).toHaveBeenCalled();
+    });
+  });
+
+  describe('getConnectedClients', () => {
+    it('should return 0 when no clients connected', () => {
+      syncService.start();
+      expect(syncService.getConnectedClients()).toBe(0);
+    });
+  });
+});

package/tests/core/vault.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { VaultManager } from '../../src/core/vault';
+import fs from 'fs/promises';
+import path from 'path';
+
+describe('VaultManager', () => {
+  let vaultManager: VaultManager;
+  const testVaultPath = '/tmp/test-vault';
+
+  beforeEach(() => {
+    vaultManager = new VaultManager();
+  });
+
+  describe('listVaults', () => {
+    it('should return empty array when no vaults are open', () => {
+      const vaults = vaultManager.listVaults();
+      expect(vaults).toEqual([]);
+    });
+  });
+
+  describe('createVault', () => {
+    it('should create a new vault', async () => {
+      const vault = vaultManager.createVault('Test Vault', testVaultPath);
+      
+      expect(vault).toBeDefined();
+      expect(vault.name).toBe('Test Vault');
+      expect(vault.path).toBe(testVaultPath);
+      expect(vault.created).toBeDefined();
+      expect(vault.notes).toEqual([]);
+    });
+
+    it('should add vault to list after creation', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      const vaults = vaultManager.listVaults();
+      
+      expect(vaults).toHaveLength(1);
+      expect(vaults[0].name).toBe('Test Vault');
+    });
+  });
+
+  describe('openVault', () => {
+    it('should return null for non-existent path', () => {
+      const vault = vaultManager.openVault('/non/existent/path');
+      expect(vault).toBeNull();
+    });
+
+    it('should open existing vault directory', async () => {
+      await fs.mkdir(testVaultPath, { recursive: true });
+      const vault = vaultManager.openVault(testVaultPath);
+      
+      expect(vault).toBeDefined();
+      expect(vault?.path).toBe(testVaultPath);
+    });
+  });
+
+  describe('createNote', () => {
+    it('should create a new note in vault', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      const note = await vaultManager.createNote(testVaultPath, 'test-note', '# Test Note\n\nContent here.');
+      
+      expect(note).toBeDefined();
+      expect(note.filename).toBe('test-note');
+      expect(note.path).toBe('test-note.md');
+      expect(note.content).toContain('# Test Note');
+      expect(note.frontmatter).toBeDefined();
+      expect(note.links).toEqual([]);
+    });
+
+    it('should extract links from note content', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      const note = await vaultManager.createNote(
+        testVaultPath,
+        'linked-note',
+        '# Linked Note\n\nSee [[Another Note]] for more.'
+      );
+      
+      expect(note.links).toContain('Another Note');
+    });
+
+    it('should extract frontmatter from note content', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      const note = await vaultManager.createNote(
+        testVaultPath,
+        'frontmatter-note',
+        '---\ntitle: My Title\ntags: [test, sample]\n---\n\nContent here.'
+      );
+      
+      expect(note.frontmatter).toHaveProperty('title', 'My Title');
+      expect(note.frontmatter).toHaveProperty('tags', '[test, sample]');
+    });
+  });
+
+  describe('readNote', () => {
+    it('should return null for non-existent note', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      const note = await vaultManager.readNote(testVaultPath, 'non-existent.md');
+      expect(note).toBeNull();
+    });
+
+    it('should read existing note', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      await vaultManager.createNote(testVaultPath, 'existing-note', '# Existing Note\n\nContent.');
+      
+      const note = await vaultManager.readNote(testVaultPath, 'existing-note.md');
+      
+      expect(note).toBeDefined();
+      expect(note?.filename).toBe('existing-note');
+      expect(note?.content).toContain('# Existing Note');
+    });
+  });
+
+  describe('updateNote', () => {
+    it('should update existing note', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      await vaultManager.createNote(testVaultPath, 'update-note', '# Original\n\nOriginal content.');
+      
+      const updatedNote = await vaultManager.updateNote(
+        testVaultPath,
+        'update-note.md',
+        '# Updated\n\nUpdated content.'
+      );
+      
+      expect(updatedNote.filename).toBe('update-note');
+      expect(updatedNote.content).toContain('# Updated');
+      expect(updatedNote.content).toContain('Updated content.');
+    });
+  });
+
+  describe('deleteNote', () => {
+    it('should delete existing note', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      await vaultManager.createNote(testVaultPath, 'delete-note', '# To Delete\n\nContent.');
+      
+      await vaultManager.deleteNote(testVaultPath, 'delete-note.md');
+      
+      const note = await vaultManager.readNote(testVaultPath, 'delete-note.md');
+      expect(note).toBeNull();
+    });
+  });
+
+  describe('searchNotes', () => {
+    it('should find notes matching query', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      await vaultManager.createNote(testVaultPath, 'note-one', '# First Note\n\nContains search term.');
+      await vaultManager.createNote(testVaultPath, 'note-two', '# Second Note\n\nDifferent content.');
+      
+      const results = await vaultManager.searchNotes(testVaultPath, 'search term');
+      
+      expect(results).toHaveLength(1);
+      expect(results[0].filename).toBe('note-one');
+    });
+
+    it('should be case insensitive', async () => {
+      vaultManager.createVault('Test Vault', testVaultPath);
+      await vaultManager.createNote(testVaultPath, 'search-test', '# Search Test\n\nUPPERCASE content.');
+      
+      const results = await vaultManager.searchNotes(testVaultPath, 'uppercase');
+      
+      expect(results).toHaveLength(1);
+    });
+  });
+});

package/tests/mcp/server.test.ts

@@ -0,0 +1,118 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { handleToolCall, tools } from '../../src/mcp/server.js';
+
+function parseToolResponse(result: Awaited<ReturnType<typeof handleToolCall>>) {
+  const first = result.content[0];
+  if (first?.type !== 'text') {
+    throw new Error('Unexpected MCP response');
+  }
+
+  return first.text;
+}
+
+describe('MCP server', () => {
+  it('exposes the expected tools', () => {
+    expect(tools.map((tool) => tool.name)).toEqual(
+      expect.arrayContaining([
+        'vault_list',
+        'vault_open',
+        'vault_create',
+        'note_create',
+        'note_read',
+        'note_update',
+        'note_delete',
+        'note_search',
+        'graph_get',
+        'graph_neighbors',
+      ])
+    );
+  });
+
+  it('handles vault, note and graph operations', async () => {
+    const vaultPath = await fs.mkdtemp(path.join(os.tmpdir(), 'opensidian-mcp-'));
+
+    const createVault = await handleToolCall('vault_create', {
+      name: 'MCP Vault',
+      path: vaultPath,
+    });
+    expect(createVault.isError).toBeUndefined();
+    expect(JSON.parse(parseToolResponse(createVault))).toEqual(
+      expect.objectContaining({ name: 'MCP Vault', path: vaultPath })
+    );
+
+    const openVault = await handleToolCall('vault_open', { path: vaultPath });
+    expect(JSON.parse(parseToolResponse(openVault))).toEqual(
+      expect.objectContaining({ path: vaultPath })
+    );
+
+    await handleToolCall('note_create', {
+      vaultPath,
+      filename: 'second',
+      content: '# Second',
+    });
+
+    const createNote = await handleToolCall('note_create', {
+      vaultPath,
+      filename: 'first',
+      content: '# First\n\nSee [[second]] for details.',
+    });
+    expect(JSON.parse(parseToolResponse(createNote))).toEqual(
+      expect.objectContaining({ filename: 'first' })
+    );
+
+    const readNote = await handleToolCall('note_read', {
+      vaultPath,
+      path: 'first.md',
+    });
+    expect(JSON.parse(parseToolResponse(readNote))).toEqual(
+      expect.objectContaining({ filename: 'first' })
+    );
+
+    const updateNote = await handleToolCall('note_update', {
+      vaultPath,
+      path: 'first.md',
+      content: '# Updated\n\nSee [[second]].',
+    });
+    expect(JSON.parse(parseToolResponse(updateNote))).toEqual(
+      expect.objectContaining({ filename: 'first' })
+    );
+
+    const searchNotes = await handleToolCall('note_search', {
+      vaultPath,
+      query: 'updated',
+    });
+    expect(JSON.parse(parseToolResponse(searchNotes))).toHaveLength(1);
+
+    const graph = await handleToolCall('graph_get', { vaultPath });
+    expect(JSON.parse(parseToolResponse(graph))).toEqual(
+      expect.objectContaining({
+        metadata: expect.objectContaining({ totalNotes: expect.any(Number) }),
+      })
+    );
+
+    const neighbors = await handleToolCall('graph_neighbors', {
+      vaultPath,
+      path: 'first.md',
+    });
+    expect(JSON.parse(parseToolResponse(neighbors))).toEqual(expect.any(Array));
+
+    const deleteNote = await handleToolCall('note_delete', {
+      vaultPath,
+      path: 'first.md',
+    });
+    expect(JSON.parse(parseToolResponse(deleteNote))).toEqual({ success: true });
+
+    await fs.rm(vaultPath, { recursive: true, force: true });
+  });
+
+  it('returns typed errors for invalid or unknown tools', async () => {
+    const invalidArgs = await handleToolCall('vault_open', {});
+    expect(invalidArgs.isError).toBe(true);
+
+    const unknownTool = await handleToolCall('not-a-tool', {});
+    expect(unknownTool.isError).toBe(true);
+    expect(parseToolResponse(unknownTool)).toContain('Unknown tool');
+  });
+});

package/tests/plugins/host.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PluginHost } from '../../src/plugins/host';
+import { Plugin } from '../../src/shared/types';
+
+describe('PluginHost', () => {
+  let host: PluginHost;
+
+  beforeEach(() => {
+    host = new PluginHost();
+  });
+
+  describe('loadPlugin', () => {
+    it('should load a valid plugin', async () => {
+      const plugin: Plugin = {
+        name: 'test-plugin',
+        version: '1.0.0',
+        async onLoad() {},
+      };
+
+      await host.loadPlugin(plugin);
+
+      const plugins = host.listPlugins();
+      expect(plugins).toContain('test-plugin');
+    });
+
+    it('should throw when loading duplicate plugin', async () => {
+      const plugin: Plugin = {
+        name: 'duplicate-plugin',
+        version: '1.0.0',
+        async onLoad() {},
+      };
+
+      await host.loadPlugin(plugin);
+      await expect(host.loadPlugin(plugin)).rejects.toThrow('already loaded');
+    });
+  });
+
+  describe('unloadPlugin', () => {
+    it('should unload existing plugin', async () => {
+      const plugin: Plugin = {
+        name: 'unload-test',
+        version: '1.0.0',
+        async onLoad() {},
+      };
+
+      await host.loadPlugin(plugin);
+      await host.unloadPlugin('unload-test');
+
+      const plugins = host.listPlugins();
+      expect(plugins).not.toContain('unload-test');
+    });
+
+    it('should call onUnload if defined', async () => {
+      const onUnload = vi.fn();
+      const plugin: Plugin = {
+        name: 'unload-callback-test',
+        version: '1.0.0',
+        async onLoad() {},
+        async onUnload() { onUnload(); },
+      };
+
+      await host.loadPlugin(plugin);
+      await host.unloadPlugin('unload-callback-test');
+
+      expect(onUnload).toHaveBeenCalled();
+    });
+
+    it('should throw when unloading non-existent plugin', async () => {
+      await expect(host.unloadPlugin('non-existent')).rejects.toThrow('not loaded');
+    });
+  });
+
+  describe('registerCommand', () => {
+    it('should register command from loaded plugin', async () => {
+      const plugin: Plugin = {
+        name: 'command-test',
+        version: '1.0.0',
+        async onLoad(context) {
+          context.registerCommand({
+            id: 'test:command',
+            label: 'Test Command',
+            execute: () => {},
+          });
+        },
+      };
+
+      await host.loadPlugin(plugin);
+
+      const command = host.getCommand('test:command');
+      expect(command).toBeDefined();
+      expect(command?.id).toBe('test:command');
+    });
+
+    it('should throw when registering duplicate command', async () => {
+      const plugin: Plugin = {
+        name: 'dup-command-test',
+        version: '1.0.0',
+        async onLoad(context) {
+          context.registerCommand({
+            id: 'test:dup',
+            label: 'Command 1',
+            execute: () => {},
+          });
+          context.registerCommand({
+            id: 'test:dup',
+            label: 'Command 2',
+            execute: () => {},
+          });
+        },
+      };
+
+      await expect(host.loadPlugin(plugin)).rejects.toThrow('already registered');
+    });
+  });
+
+  describe('registerHook', () => {
+    it('should register hook from loaded plugin', async () => {
+      const handler = vi.fn();
+      const plugin: Plugin = {
+        name: 'hook-test',
+        version: '1.0.0',
+        async onLoad(context) {
+          context.registerHook('test:hook', handler);
+        },
+      };
+
+      await host.loadPlugin(plugin);
+      const results = await host.executeHook('test:hook', 'arg');
+
+      expect(handler).toHaveBeenCalledWith('arg');
+      expect(results).toContain(handler());
+    });
+  });
+
+  describe('listCommands', () => {
+    it('should list all registered commands', async () => {
+      const plugin: Plugin = {
+        name: 'list-commands-test',
+        version: '1.0.0',
+        async onLoad(context) {
+          context.registerCommand({ id: 'cmd1', label: 'Cmd 1', execute: () => {} });
+          context.registerCommand({ id: 'cmd2', label: 'Cmd 2', execute: () => {} });
+        },
+      };
+
+      await host.loadPlugin(plugin);
+      const commands = host.listCommands();
+
+      expect(commands).toHaveLength(2);
+    });
+  });
+
+  describe('listPlugins', () => {
+    it('should list all loaded plugins', async () => {
+      await host.loadPlugin({ name: 'plugin1', version: '1.0.0', async onLoad() {} });
+      await host.loadPlugin({ name: 'plugin2', version: '1.0.0', async onLoad() {} });
+
+      const plugins = host.listPlugins();
+
+      expect(plugins).toContain('plugin1');
+      expect(plugins).toContain('plugin2');
+      expect(plugins).toHaveLength(2);
+    });
+  });
+});

package/tests/plugins/sample-plugin.test.ts

@@ -0,0 +1,35 @@
+import samplePlugin from '../../src/plugins/sample-plugin.js';
+import { PluginHost } from '../../src/plugins/host.js';
+
+describe('SamplePlugin', () => {
+  it('registers command and hooks when loaded', async () => {
+    const host = new PluginHost();
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    await host.loadPlugin(samplePlugin);
+
+    const command = host.getCommand('sample:greet');
+    expect(command).toBeDefined();
+
+    await command?.execute();
+    const results = await host.executeHook('note:pre-save', {
+      path: 'note.md',
+      content: '# Hello',
+    });
+
+    expect(logSpy).toHaveBeenCalledWith('Hello from sample plugin!');
+    expect(results).toEqual([
+      {
+        path: 'note.md',
+        content: '# Hello',
+      },
+    ]);
+
+    await host.executeHook('note:post-save', { path: 'note.md' });
+    await host.unloadPlugin(samplePlugin.name);
+
+    expect(host.listPlugins()).not.toContain(samplePlugin.name);
+
+    logSpy.mockRestore();
+  });
+});

package/tests/server.test.ts

@@ -0,0 +1,76 @@
+import net from 'net';
+import { WebSocket } from 'ws';
+import { OpenSidianServer } from '../src/server.js';
+
+async function getFreePort(): Promise<number> {
+  return await new Promise<number>((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      if (!address || typeof address === 'string') {
+        reject(new Error('Unable to allocate port'));
+        return;
+      }
+
+      const { port } = address;
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(port);
+      });
+    });
+  });
+}
+
+async function wait(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe('OpenSidianServer', () => {
+  it('starts, serves health, handles websocket messages and stops', async () => {
+    const port = await getFreePort();
+    const syncPort = await getFreePort();
+    const server = new OpenSidianServer({
+      server: { port, host: '127.0.0.1' },
+      sync: { enabled: true, port: syncPort },
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+
+    server.start();
+    await wait(100);
+
+    const healthResponse = await fetch(`http://127.0.0.1:${port}/health`);
+    expect(healthResponse.status).toBe(200);
+    expect(await healthResponse.json()).toEqual(
+      expect.objectContaining({ status: 'ok' })
+    );
+
+    const socket = new WebSocket(`ws://127.0.0.1:${port}`);
+    await new Promise<void>((resolve, reject) => {
+      socket.once('open', () => resolve());
+      socket.once('error', (error) => reject(error));
+    });
+
+    socket.send(JSON.stringify({ hello: 'world' }));
+    socket.send('not-json');
+    await wait(50);
+
+    expect(logSpy).toHaveBeenCalledWith('WebSocket message:', { hello: 'world' });
+    expect(errorSpy).toHaveBeenCalled();
+
+    socket.close();
+    server.stop();
+
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  it('stops safely even when never started', () => {
+    const server = new OpenSidianServer();
+    expect(() => server.stop()).not.toThrow();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vite.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, './src'),
+    },
+  },
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      name: 'OpenSidian',
+      fileName: 'opensidian',
+    },
+    rollupOptions: {
+      external: ['express', 'ws', 'cors'],
+      output: {
+        globals: {
+          express: 'express',
+          ws: 'ws',
+          cors: 'cors',
+        },
+      },
+    },
+  },
+});