opensidian 1.0.0

package/src/core/sync.ts

@@ -0,0 +1,157 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { EventEmitter } from 'events';
+
+interface SyncMessage {
+  type: 'note_created' | 'note_updated' | 'note_deleted' | 'sync_request' | 'sync_response';
+  vaultPath?: string;
+  note?: {
+    path: string;
+    content?: string;
+    timestamp?: string;
+  };
+  timestamp?: string;
+}
+
+interface Client {
+  id: string;
+  socket: WebSocket;
+  subscribedVaults: Set<string>;
+}
+
+export class SyncService extends EventEmitter {
+  private wss: WebSocketServer | null = null;
+  private clients: Map<string, Client> = new Map();
+  private port: number;
+  private isRunning: boolean = false;
+
+  constructor(port: number = 3001) {
+    super();
+    this.port = port;
+  }
+
+  start(): void {
+    if (this.isRunning) return;
+
+    this.wss = new WebSocketServer({ port: this.port });
+
+    this.wss.on('connection', (socket) => {
+      const clientId = this.generateClientId();
+      const client: Client = {
+        id: clientId,
+        socket,
+        subscribedVaults: new Set(),
+      };
+      this.clients.set(clientId, client);
+
+      socket.on('message', (data) => {
+        try {
+          const message: SyncMessage = JSON.parse(data.toString());
+          this.handleMessage(client, message);
+        } catch (error) {
+          console.error('Invalid sync message:', error);
+        }
+      });
+
+      socket.on('close', () => {
+        this.clients.delete(clientId);
+      });
+
+      socket.on('error', (error) => {
+        console.error('WebSocket error:', error);
+        this.clients.delete(clientId);
+      });
+    });
+
+    this.isRunning = true;
+    console.error(`Sync service running on port ${this.port}`);
+  }
+
+  stop(): void {
+    if (!this.isRunning) return;
+
+    for (const client of this.clients.values()) {
+      client.socket.close();
+    }
+    this.clients.clear();
+
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+
+    this.isRunning = false;
+  }
+
+  broadcastChange(message: SyncMessage): void {
+    const vaultPath = message.note?.path 
+      ? message.note.path.split('/')[0] 
+      : undefined;
+    
+    const fullMessage: SyncMessage = {
+      ...message,
+      timestamp: new Date().toISOString(),
+    };
+
+    for (const client of this.clients.values()) {
+      if (vaultPath && client.subscribedVaults.has(vaultPath)) {
+        this.sendToClient(client, fullMessage);
+      } else if (!vaultPath) {
+        this.sendToClient(client, fullMessage);
+      }
+    }
+
+    this.emit('change', fullMessage);
+  }
+
+  subscribeToVault(clientId: string, vaultPath: string): boolean {
+    const client = this.clients.get(clientId);
+    if (!client) return false;
+
+    client.subscribedVaults.add(vaultPath);
+    return true;
+  }
+
+  unsubscribeFromVault(clientId: string, vaultPath: string): boolean {
+    const client = this.clients.get(clientId);
+    if (!client) return false;
+
+    client.subscribedVaults.delete(vaultPath);
+    return true;
+  }
+
+  private handleMessage(client: Client, message: SyncMessage): void {
+    switch (message.type) {
+      case 'sync_request':
+        this.handleSyncRequest(client, message);
+        break;
+      case 'note_created':
+      case 'note_updated':
+      case 'note_deleted':
+        this.broadcastChange(message);
+        break;
+    }
+  }
+
+  private handleSyncRequest(client: Client, _message: SyncMessage): void {
+    // Send acknowledgment with current state
+    const response: SyncMessage = {
+      type: 'sync_response',
+      timestamp: new Date().toISOString(),
+    };
+    this.sendToClient(client, response);
+  }
+
+  private sendToClient(client: Client, message: SyncMessage): void {
+    if (client.socket.readyState === WebSocket.OPEN) {
+      client.socket.send(JSON.stringify(message));
+    }
+  }
+
+  private generateClientId(): string {
+    return `client_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  getConnectedClients(): number {
+    return this.clients.size;
+  }
+}

package/src/core/vault.ts

@@ -0,0 +1,286 @@
+import fs from 'fs/promises';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import path from 'path';
+import { Note, Vault } from '../shared/types.js';
+import { FullTextIndexer, SearchResult, SearchDoc } from './search.js';
+
+export class VaultManager {
+  private vaults: Map<string, Vault> = new Map();
+  private indexer: FullTextIndexer;
+
+  constructor(indexDir?: string) {
+    this.indexer = new FullTextIndexer(indexDir);
+  }
+
+  async initIndex(): Promise<void> {
+    await this.indexer.load();
+  }
+
+  async persistIndex(): Promise<void> {
+    await this.indexer.save();
+  }
+
+  listVaults(): Vault[] {
+    return Array.from(this.vaults.values());
+  }
+
+  openVault(vaultPath: string): Vault | null {
+    try {
+      const stat = statSync(vaultPath);
+      if (!stat.isDirectory()) {
+        throw new Error('Vault path is not a directory');
+      }
+    } catch {
+      return null;
+    }
+
+    const vaultConfigPath = path.join(vaultPath, '.vault.json');
+    let config: Partial<Vault> = {};
+
+    try {
+      const configData = readFileSync(vaultConfigPath, 'utf-8');
+      config = JSON.parse(configData);
+    } catch {
+      config = { name: path.basename(vaultPath) };
+    }
+
+    const vault: Vault = {
+      path: vaultPath,
+      name: config.name || path.basename(vaultPath),
+      created: config.created || new Date().toISOString(),
+      notes: this.loadNotesFromVault(vaultPath),
+    };
+
+    this.vaults.set(vaultPath, vault);
+
+    for (const note of vault.notes) {
+      this.indexer.indexNote(this.toSearchDoc(note, vaultPath));
+    }
+
+    return vault;
+  }
+
+  createVault(name: string, vaultPath: string): Vault {
+    const vault: Vault = {
+      path: vaultPath,
+      name,
+      created: new Date().toISOString(),
+      notes: [],
+    };
+
+    fs.mkdir(vaultPath, { recursive: true }).catch(console.error);
+    fs.writeFile(
+      path.join(vaultPath, '.vault.json'),
+      JSON.stringify({ name, created: vault.created }, null, 2)
+    ).catch(console.error);
+
+    this.vaults.set(vaultPath, vault);
+    return vault;
+  }
+
+  async createNote(vaultPath: string, filename: string, content: string): Promise<Note> {
+    const filePath = path.join(vaultPath, `${filename}.md`);
+    const parsed = this.parseMarkdown(content);
+    
+    const note: Note = {
+      path: `${filename}.md`,
+      filename,
+      content,
+      frontmatter: parsed.frontmatter,
+      links: parsed.links,
+      created: new Date().toISOString(),
+      modified: new Date().toISOString(),
+    };
+
+    await fs.writeFile(filePath, content);
+    this.upsertNoteInVault(vaultPath, note);
+    this.indexer.indexNote(this.toSearchDoc(note, vaultPath));
+
+    return note;
+  }
+
+  async readNote(vaultPath: string, notePath: string): Promise<Note | null> {
+    const fullPath = path.join(vaultPath, notePath);
+    
+    try {
+      const stat = await fs.stat(fullPath);
+      if (!stat.isFile() || !notePath.endsWith('.md')) {
+        return null;
+      }
+
+      const content = await fs.readFile(fullPath, 'utf-8');
+      const parsed = this.parseMarkdown(content);
+      const filename = path.basename(notePath, '.md');
+
+      return {
+        path: notePath,
+        filename,
+        content,
+        frontmatter: parsed.frontmatter,
+        links: parsed.links,
+        created: stat.birthtime.toISOString(),
+        modified: stat.mtime.toISOString(),
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  async updateNote(vaultPath: string, notePath: string, content: string): Promise<Note> {
+    const fullPath = path.join(vaultPath, notePath);
+    const parsed = this.parseMarkdown(content);
+    
+    const note: Note = {
+      path: notePath,
+      filename: path.basename(notePath, '.md'),
+      content,
+      frontmatter: parsed.frontmatter,
+      links: parsed.links,
+      modified: new Date().toISOString(),
+      created: (await this.readNote(vaultPath, notePath))?.created || new Date().toISOString(),
+    };
+
+    await fs.writeFile(fullPath, content);
+    this.upsertNoteInVault(vaultPath, note);
+    this.indexer.indexNote(this.toSearchDoc(note, vaultPath));
+    return note;
+  }
+
+  async deleteNote(vaultPath: string, notePath: string): Promise<void> {
+    const fullPath = path.join(vaultPath, notePath);
+    await fs.unlink(fullPath);
+    
+    const vault = this.vaults.get(vaultPath);
+    if (vault) {
+      vault.notes = vault.notes.filter(n => n.path !== notePath);
+    }
+    this.indexer.removeNote(notePath);
+  }
+
+  async searchNotes(vaultPath: string, query: string): Promise<Note[]> {
+    const results: Note[] = [];
+    const vault = this.vaults.get(vaultPath) ?? this.openVault(vaultPath);
+    
+    if (!vault) return results;
+
+    for (const note of vault.notes) {
+      if (note.content.toLowerCase().includes(query.toLowerCase())) {
+        results.push(note);
+      }
+    }
+
+    return results;
+  }
+
+  async fullTextSearch(vaultPath: string, query: string, filters?: {
+    tag?: string;
+    after?: string;
+    before?: string;
+    hasBacklinks?: boolean;
+  }): Promise<SearchResult[]> {
+    const vault = this.vaults.get(vaultPath) ?? this.openVault(vaultPath);
+    if (!vault) return [];
+
+    const docs = vault.notes.map(n => this.toSearchDoc(n, vaultPath));
+    return this.indexer.search(query, docs, filters);
+  }
+
+  private toSearchDoc(note: Note, _vaultPath: string): SearchDoc {
+    return {
+      path: note.path,
+      filename: note.filename,
+      content: note.content,
+      tags: Array.isArray(note.frontmatter?.tags)
+        ? (note.frontmatter.tags as string[]).map(String)
+        : typeof note.frontmatter?.tags === 'string'
+          ? (note.frontmatter.tags as string).split(',').map(t => t.trim())
+          : [],
+      modified: note.modified,
+      backlinks: note.links.length,
+    };
+  }
+
+  private parseMarkdown(content: string): { frontmatter: Record<string, unknown>, links: string[] } {
+    const frontmatter: Record<string, unknown> = {};
+    const links: string[] = [];
+
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+      try {
+        const fmContent = frontmatterMatch[1];
+        fmContent.split('\n').forEach(line => {
+          const [key, ...valueParts] = line.split(':');
+          if (key && valueParts.length > 0) {
+            frontmatter[key.trim()] = valueParts.join(':').trim();
+          }
+        });
+      } catch {
+        // Invalid frontmatter, ignore
+      }
+    }
+
+    const wikiLinkRegex = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+    const mdLinkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+    
+    let match;
+    while ((match = wikiLinkRegex.exec(content)) !== null) {
+      links.push(match[1]);
+    }
+    while ((match = mdLinkRegex.exec(content)) !== null) {
+      if (!match[2].startsWith('http')) {
+        links.push(match[2].replace(/\.md$/, ''));
+      }
+    }
+
+    return { frontmatter, links };
+  }
+
+  private loadNotesFromVault(vaultPath: string): Note[] {
+    if (!existsSync(vaultPath)) {
+      return [];
+    }
+
+    const notes: Note[] = [];
+
+    for (const entry of readdirSync(vaultPath)) {
+      if (!entry.endsWith('.md')) {
+        continue;
+      }
+
+      const fullPath = path.join(vaultPath, entry);
+      const stat = statSync(fullPath);
+      if (!stat.isFile()) {
+        continue;
+      }
+
+      const content = readFileSync(fullPath, 'utf-8');
+      const parsed = this.parseMarkdown(content);
+      notes.push({
+        path: entry,
+        filename: path.basename(entry, '.md'),
+        content,
+        frontmatter: parsed.frontmatter,
+        links: parsed.links,
+        created: stat.birthtime.toISOString(),
+        modified: stat.mtime.toISOString(),
+      });
+    }
+
+    return notes;
+  }
+
+  private upsertNoteInVault(vaultPath: string, note: Note): void {
+    const vault = this.vaults.get(vaultPath) ?? this.openVault(vaultPath);
+    if (!vault) {
+      return;
+    }
+
+    const noteIndex = vault.notes.findIndex((existingNote) => existingNote.path === note.path);
+    if (noteIndex >= 0) {
+      vault.notes[noteIndex] = note;
+      return;
+    }
+
+    vault.notes.push(note);
+  }
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+import { OpenSidianServer } from './server.js';
+import { Config } from './shared/types.js';
+
+const config: Partial<Config> = {
+  server: {
+    port: parseInt(process.env.PORT || '3000', 10),
+    host: process.env.HOST || '0.0.0.0',
+  },
+  vaults: {
+    defaultPath: process.env.VAULT_PATH || './vaults',
+    autoOpen: true,
+  },
+  sync: {
+    enabled: process.env.SYNC_ENABLED !== 'false',
+    port: parseInt(process.env.SYNC_PORT || '3001', 10),
+  },
+  plugins: {
+    enabled: process.env.PLUGINS_ENABLED !== 'false',
+    paths: process.env.PLUGIN_PATHS?.split(',') || ['./plugins'],
+  },
+};
+
+const server = new OpenSidianServer(config);
+
+process.on('SIGTERM', () => {
+  console.log('SIGTERM received, shutting down...');
+  server.stop();
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  console.log('SIGINT received, shutting down...');
+  server.stop();
+  process.exit(0);
+});
+
+server.start();

package/src/mcp/cli.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startServer } from './server.js';
+
+startServer().catch((err) => {
+  console.error('MCP Server failed:', err);
+  process.exit(1);
+});