opensidian 1.0.0

package/src/mcp/server.ts

@@ -0,0 +1,296 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  Tool,
+} from '@modelcontextprotocol/sdk/types.js';
+import { VaultManager } from '../core/vault.js';
+import { GraphEngine } from '../core/graph.js';
+import { SyncService } from '../core/sync.js';
+import { z } from 'zod';
+
+const vaultManager = new VaultManager();
+const graphEngine = new GraphEngine();
+const syncService = new SyncService();
+
+const tools: Tool[] = [
+  {
+    name: 'vault_list',
+    description: 'List all available vaults',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'vault_open',
+    description: 'Open a specific vault',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path to the vault' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'vault_create',
+    description: 'Create a new vault',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Name of the vault' },
+        path: { type: 'string', description: 'Path where to create the vault' },
+      },
+      required: ['name', 'path'],
+    },
+  },
+  {
+    name: 'note_create',
+    description: 'Create a new note',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        vaultPath: { type: 'string', description: 'Path to the vault' },
+        filename: { type: 'string', description: 'Note filename (without .md)' },
+        content: { type: 'string', description: 'Note content in markdown' },
+      },
+      required: ['vaultPath', 'filename', 'content'],
+    },
+  },
+  {
+    name: 'note_read',
+    description: 'Read a note',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        vaultPath: { type: 'string', description: 'Path to the vault' },
+        path: { type: 'string', description: 'Path to the note relative to vault' },
+      },
+      required: ['vaultPath', 'path'],
+    },
+  },
+  {
+    name: 'note_update',
+    description: 'Update a note',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        vaultPath: { type: 'string', description: 'Path to the vault' },
+        path: { type: 'string', description: 'Path to the note relative to vault' },
+        content: { type: 'string', description: 'New content in markdown' },
+      },
+      required: ['vaultPath', 'path', 'content'],
+    },
+  },
+  {
+    name: 'note_delete',
+    description: 'Delete a note',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        vaultPath: { type: 'string', description: 'Path to the vault' },
+        path: { type: 'string', description: 'Path to the note relative to vault' },
+      },
+      required: ['vaultPath', 'path'],
+    },
+  },
+  {
+    name: 'note_search',
+    description: 'Full-text search notes with ranking, highlighting, and optional filters',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        vaultPath: { type: 'string', description: 'Path to the vault' },
+        query: { type: 'string', description: 'Search query' },
+        tag: { type: 'string', description: 'Filter by tag (e.g. "javascript")' },
+        after: { type: 'string', description: 'Filter by date after (ISO string, e.g. "2026-01-01")' },
+        before: { type: 'string', description: 'Filter by date before (ISO string)' },
+        hasBacklinks: { type: 'boolean', description: 'Filter by presence of backlinks' },
+      },
+      required: ['vaultPath', 'query'],
+    },
+  },
+  {
+    name: 'graph_get',
+    description: 'Get knowledge graph data',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        vaultPath: { type: 'string', description: 'Path to the vault' },
+      },
+      required: ['vaultPath'],
+    },
+  },
+  {
+    name: 'graph_neighbors',
+    description: 'Get linked notes for a specific note',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        vaultPath: { type: 'string', description: 'Path to the vault' },
+        path: { type: 'string', description: 'Path to the note' },
+      },
+      required: ['vaultPath', 'path'],
+    },
+  },
+];
+
+const server = new Server(
+  { name: 'opensidian-mcp', version: '0.1.0' },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools };
+});
+
+export async function handleToolCall(name: string, args: unknown) {
+  try {
+    switch (name) {
+      case 'vault_list': {
+        const vaults = vaultManager.listVaults();
+        return {
+          content: [{ type: 'text', text: JSON.stringify(vaults, null, 2) }],
+        };
+      }
+
+      case 'vault_open': {
+        const schema = z.object({ path: z.string() });
+        const { path } = schema.parse(args);
+        const vault = vaultManager.openVault(path);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(vault, null, 2) }],
+        };
+      }
+
+      case 'vault_create': {
+        const schema = z.object({ name: z.string(), path: z.string() });
+        const { name, path } = schema.parse(args);
+        const vault = vaultManager.createVault(name, path);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(vault, null, 2) }],
+        };
+      }
+
+      case 'note_create': {
+        const schema = z.object({
+          vaultPath: z.string(),
+          filename: z.string(),
+          content: z.string(),
+        });
+        const { vaultPath, filename, content } = schema.parse(args);
+        const note = await vaultManager.createNote(vaultPath, filename, content);
+        graphEngine.indexNote(vaultPath, note);
+        syncService.broadcastChange({ type: 'note_created', note });
+        return {
+          content: [{ type: 'text', text: JSON.stringify(note, null, 2) }],
+        };
+      }
+
+      case 'note_read': {
+        const schema = z.object({ vaultPath: z.string(), path: z.string() });
+        const { vaultPath, path } = schema.parse(args);
+        const note = await vaultManager.readNote(vaultPath, path);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(note, null, 2) }],
+        };
+      }
+
+      case 'note_update': {
+        const schema = z.object({
+          vaultPath: z.string(),
+          path: z.string(),
+          content: z.string(),
+        });
+        const { vaultPath, path, content } = schema.parse(args);
+        const note = await vaultManager.updateNote(vaultPath, path, content);
+        graphEngine.indexNote(vaultPath, note);
+        syncService.broadcastChange({ type: 'note_updated', note });
+        return {
+          content: [{ type: 'text', text: JSON.stringify(note, null, 2) }],
+        };
+      }
+
+      case 'note_delete': {
+        const schema = z.object({ vaultPath: z.string(), path: z.string() });
+        const { vaultPath, path } = schema.parse(args);
+        await vaultManager.deleteNote(vaultPath, path);
+        graphEngine.removeNote(vaultPath, path);
+        syncService.broadcastChange({ type: 'note_deleted', note: { path } });
+        return {
+          content: [{ type: 'text', text: JSON.stringify({ success: true }, null, 2) }],
+        };
+      }
+
+      case 'note_search': {
+        const schema = z.object({
+          vaultPath: z.string(),
+          query: z.string(),
+          tag: z.string().optional(),
+          after: z.string().optional(),
+          before: z.string().optional(),
+          hasBacklinks: z.boolean().optional(),
+        });
+        const { vaultPath, query, tag, after, before, hasBacklinks } = schema.parse(args);
+        const results = await vaultManager.fullTextSearch(vaultPath, query, { tag, after, before, hasBacklinks });
+        return {
+          content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+        };
+      }
+
+      case 'graph_get': {
+        const schema = z.object({ vaultPath: z.string() });
+        const { vaultPath } = schema.parse(args);
+        const graph = graphEngine.getGraph(vaultPath);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(graph, null, 2) }],
+        };
+      }
+
+      case 'graph_neighbors': {
+        const schema = z.object({ vaultPath: z.string(), path: z.string() });
+        const { vaultPath, path } = schema.parse(args);
+        const neighbors = graphEngine.getNeighbors(vaultPath, path);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(neighbors, null, 2) }],
+        };
+      }
+
+      default:
+        return {
+          content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+          isError: true,
+        };
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: error instanceof Error ? error.message : String(error),
+        },
+      ],
+      isError: true,
+    };
+  }
+}
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  return handleToolCall(name, args);
+});
+
+export async function startServer() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('OpenSidian MCP Server running on stdio');
+}
+
+export { tools };
+

package/src/plugins/host.ts

@@ -0,0 +1,120 @@
+import { Plugin, PluginContext, PluginCommand } from '../shared/types.js';
+import { VaultManager } from '../core/vault.js';
+import { GraphEngine } from '../core/graph.js';
+
+export class PluginHost {
+  private plugins: Map<string, Plugin> = new Map();
+  private commands: Map<string, PluginCommand> = new Map();
+  private hooks: Map<string, Function[]> = new Map();
+  private vaultManager: VaultManager;
+  private graphEngine: GraphEngine;
+
+  constructor() {
+    this.vaultManager = new VaultManager();
+    this.graphEngine = new GraphEngine();
+  }
+
+  async loadPlugin(plugin: Plugin): Promise<void> {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin ${plugin.name} is already loaded`);
+    }
+
+    const context = this.createContext(plugin.name);
+    
+    try {
+      await plugin.onLoad(context);
+      this.plugins.set(plugin.name, plugin);
+      console.error(`Plugin ${plugin.name} loaded successfully`);
+    } catch (error) {
+      console.error(`Failed to load plugin ${plugin.name}:`, error);
+      throw error;
+    }
+  }
+
+  async unloadPlugin(name: string): Promise<void> {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      throw new Error(`Plugin ${name} is not loaded`);
+    }
+
+    if (plugin.onUnload) {
+      await plugin.onUnload();
+    }
+
+    for (const [commandId, command] of this.commands.entries()) {
+      if ((command as unknown as { pluginName?: string }).pluginName === name) {
+        this.commands.delete(commandId);
+      }
+    }
+
+    for (const [hookName, handlers] of this.hooks.entries()) {
+      const filtered = handlers.filter(h => (h as unknown as { pluginName?: string }).pluginName !== name);
+      if (filtered.length === 0) {
+        this.hooks.delete(hookName);
+      } else {
+        this.hooks.set(hookName, filtered);
+      }
+    }
+
+    this.plugins.delete(name);
+    console.error(`Plugin ${name} unloaded`);
+  }
+
+  registerCommand(command: PluginCommand & { pluginName?: string }): void {
+    if (this.commands.has(command.id)) {
+      throw new Error(`Command ${command.id} is already registered`);
+    }
+    (command as unknown as { pluginName?: string }).pluginName = command.pluginName;
+    this.commands.set(command.id, command);
+  }
+
+  registerHook(hook: string, handler: Function & { pluginName?: string }, pluginName?: string): void {
+    if (!this.hooks.has(hook)) {
+      this.hooks.set(hook, []);
+    }
+    (handler as unknown as { pluginName?: string }).pluginName = pluginName;
+    this.hooks.get(hook)!.push(handler);
+  }
+
+  async executeHook(hook: string, ...args: unknown[]): Promise<unknown[]> {
+    const handlers = this.hooks.get(hook) || [];
+    const results: unknown[] = [];
+    
+    for (const handler of handlers) {
+      try {
+        const result = await handler(...args);
+        results.push(result);
+      } catch (error) {
+        console.error(`Error in hook ${hook}:`, error);
+        results.push(undefined);
+      }
+    }
+    
+    return results;
+  }
+
+  getCommand(id: string): PluginCommand | undefined {
+    return this.commands.get(id);
+  }
+
+  listCommands(): PluginCommand[] {
+    return Array.from(this.commands.values());
+  }
+
+  listPlugins(): string[] {
+    return Array.from(this.plugins.keys());
+  }
+
+  private createContext(pluginName: string): PluginContext {
+    return {
+      registerCommand: (command: PluginCommand) => {
+        this.registerCommand({ ...command, pluginName });
+      },
+      registerHook: (hook: string, handler: Function) => {
+        this.registerHook(hook, handler, pluginName);
+      },
+      getVaultManager: () => this.vaultManager,
+      getGraphEngine: () => this.graphEngine,
+    };
+  }
+}

package/src/plugins/sample-plugin.ts

@@ -0,0 +1,29 @@
+import { Plugin, PluginContext } from '../shared/types.js';
+
+export class SamplePlugin implements Plugin {
+  name = 'sample-plugin';
+  version = '1.0.0';
+
+  async onLoad(context: PluginContext): Promise<void> {
+    context.registerCommand({
+      id: 'sample:greet',
+      label: 'Greet',
+      execute: () => console.log('Hello from sample plugin!'),
+    });
+
+    context.registerHook('note:pre-save', (note: { path: string; content: string }) => {
+      console.log(`Sample plugin: note ${note.path} is being saved`);
+      return note;
+    });
+
+    context.registerHook('note:post-save', (note: { path: string }) => {
+      console.log(`Sample plugin: note ${note.path} has been saved`);
+    });
+  }
+
+  async onUnload(): Promise<void> {
+    console.log('Sample plugin unloading...');
+  }
+}
+
+export default new SamplePlugin();

package/src/server.ts

@@ -0,0 +1,90 @@
+import express from 'express';
+import cors from 'cors';
+import { createServer } from 'http';
+import path from 'path';
+import { existsSync } from 'fs';
+import { WebSocketServer } from 'ws';
+import routes from './api/routes.js';
+import authRoutes from './api/auth.js';
+import themeRoutes from './api/themes.js';
+import { SyncService } from './core/sync.js';
+import { Config } from './shared/types.js';
+
+export class OpenSidianServer {
+  private app: express.Application;
+  private httpServer: ReturnType<typeof createServer> | null = null;
+  private wss: WebSocketServer | null = null;
+  private syncService: SyncService;
+  private port: number;
+  private host: string;
+
+  constructor(config: Partial<Config> = {}) {
+    this.port = config.server?.port || 3000;
+    this.host = config.server?.host || '0.0.0.0';
+    this.syncService = new SyncService(config.sync?.port || 3001);
+    
+    this.app = express();
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+
+  private setupMiddleware(): void {
+    this.app.use(cors());
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+  }
+
+  private setupRoutes(): void {
+    this.app.get('/health', (_req, res) => {
+      res.json({ status: 'ok', timestamp: new Date().toISOString() });
+    });
+
+    this.app.use('/api', routes);
+    this.app.use('/auth', authRoutes);
+    this.app.use('/api/themes', themeRoutes);
+
+    const webDist = path.resolve(process.cwd(), 'web', 'dist');
+    if (existsSync(webDist)) {
+      this.app.use(express.static(webDist));
+      this.app.get('*', (_req, res) => {
+        res.sendFile(path.join(webDist, 'index.html'));
+      });
+    }
+  }
+
+  start(): void {
+    this.httpServer = createServer(this.app);
+
+    this.wss = new WebSocketServer({ server: this.httpServer });
+    this.wss.on('connection', (socket) => {
+      socket.on('message', (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          console.log('WebSocket message:', message);
+        } catch (error) {
+          console.error('Invalid WebSocket message:', error);
+        }
+      });
+    });
+
+    this.syncService.start();
+
+    this.httpServer.listen(this.port, this.host, () => {
+      console.error(`OpenSidian server running at http://${this.host}:${this.port}`);
+    });
+  }
+
+  stop(): void {
+    this.syncService.stop();
+    
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+
+    if (this.httpServer) {
+      this.httpServer.close();
+      this.httpServer = null;
+    }
+  }
+}

package/src/shared/types.ts

@@ -0,0 +1,92 @@
+import type { GraphEngine } from '../core/graph.js';
+import type { VaultManager } from '../core/vault.js';
+
+export interface Vault {
+  path: string;
+  name: string;
+  created: string;
+  notes: Note[];
+}
+
+export interface Note {
+  path: string;
+  filename: string;
+  content: string;
+  frontmatter: Record<string, unknown>;
+  links: string[];
+  created: string;
+  modified: string;
+}
+
+export interface ParsedNote<T extends Record<string, unknown> = Record<string, unknown>> {
+  frontmatter: T;
+  body: string;
+  html: string;
+  links: string[];
+  headings: Array<{ level: number; text: string; id: string }>;
+}
+
+export interface Graph {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+  metadata: GraphMetadata;
+}
+
+export interface GraphNode {
+  id: string;
+  label: string;
+  tags?: string[];
+  connections?: number;
+}
+
+export interface GraphEdge {
+  id: string;
+  source: string;
+  target: string;
+  type: 'wikilink' | 'mdlink' | 'tag';
+}
+
+export interface GraphMetadata {
+  totalNotes: number;
+  totalLinks: number;
+}
+
+export interface Plugin {
+  name: string;
+  version: string;
+  onLoad(context: PluginContext): Promise<void> | void;
+  onUnload?(): Promise<void> | void;
+}
+
+export interface PluginContext {
+  registerCommand(command: PluginCommand): void;
+  registerHook(hook: string, handler: Function): void;
+  getVaultManager(): VaultManager;
+  getGraphEngine(): GraphEngine;
+}
+
+export interface PluginCommand {
+  id: string;
+  label: string;
+  icon?: string;
+  execute(): void | Promise<void>;
+}
+
+export interface Config {
+  server: {
+    port: number;
+    host: string;
+  };
+  vaults: {
+    defaultPath: string;
+    autoOpen: boolean;
+  };
+  sync: {
+    enabled: boolean;
+    port: number;
+  };
+  plugins: {
+    enabled: boolean;
+    paths: string[];
+  };
+}