opensidian 1.0.0

package/src/api/routes.ts

@@ -0,0 +1,133 @@
+import express, { Request, Response, NextFunction } from 'express';
+import { VaultManager } from '../core/vault.js';
+import { GraphEngine } from '../core/graph.js';
+
+const router = express.Router();
+const vaultManager = new VaultManager();
+const graphEngine = new GraphEngine();
+
+router.get('/vaults', (_req: Request, res: Response) => {
+  const vaults = vaultManager.listVaults();
+  return res.json({ vaults });
+});
+
+router.post('/vaults', (req: Request, res: Response) => {
+  const { name, path } = req.body;
+  if (!name || !path) {
+    return res.status(400).json({ error: 'name and path are required' });
+  }
+  const vault = vaultManager.createVault(name, path);
+  return res.status(201).json({ vault });
+});
+
+router.get('/vaults/:id', (req: Request, res: Response) => {
+  const vault = vaultManager.openVault(req.params.id);
+  if (!vault) {
+    return res.status(404).json({ error: 'Vault not found' });
+  }
+  return res.json({ vault });
+});
+
+router.delete('/vaults/:id', (_req: Request, res: Response) => {
+  return res.status(501).json({ error: 'Not implemented' });
+});
+
+router.get('/notes', (req: Request, res: Response) => {
+  const vaultPath = req.query.vault as string;
+  if (!vaultPath) {
+    return res.status(400).json({ error: 'vault query parameter is required' });
+  }
+  const vault = vaultManager.openVault(vaultPath);
+  if (!vault) {
+    return res.status(404).json({ error: 'Vault not found' });
+  }
+  return res.json({ notes: vault.notes });
+});
+
+router.post('/notes', async (req: Request, res: Response) => {
+  const { vaultPath, filename, content } = req.body;
+  if (!vaultPath || !filename || !content) {
+    return res.status(400).json({ error: 'vaultPath, filename, and content are required' });
+  }
+  const note = await vaultManager.createNote(vaultPath, filename, content);
+  graphEngine.indexNote(vaultPath, note);
+  return res.status(201).json({ note });
+});
+
+router.get('/notes/search', async (req: Request, res: Response) => {
+  const vaultPath = req.query.vault as string;
+  const q = req.query.q as string;
+  if (!vaultPath || !q) {
+    return res.status(400).json({ error: 'vault and q parameters are required' });
+  }
+  const tag = req.query.tag as string | undefined;
+  const after = req.query.after as string | undefined;
+  const before = req.query.before as string | undefined;
+  const hasBacklinks = req.query.hasBacklinks === 'true' ? true : req.query.hasBacklinks === 'false' ? false : undefined;
+  const results = await vaultManager.fullTextSearch(vaultPath, q, { tag, after, before, hasBacklinks });
+  return res.json({ results });
+});
+
+router.get('/notes/:path(*)', async (req: Request, res: Response) => {
+  const vaultPath = req.query.vault as string;
+  if (!vaultPath) {
+    return res.status(400).json({ error: 'vault query parameter is required' });
+  }
+  const note = await vaultManager.readNote(vaultPath, req.params.path);
+  if (!note) {
+    return res.status(404).json({ error: 'Note not found' });
+  }
+  return res.json({ note });
+});
+
+router.put('/notes/:path(*)', async (req: Request, res: Response) => {
+  const vaultPath = req.query.vault as string;
+  const { content } = req.body;
+  if (!vaultPath) {
+    return res.status(400).json({ error: 'vault query parameter is required' });
+  }
+  if (!content) {
+    return res.status(400).json({ error: 'content is required' });
+  }
+  const note = await vaultManager.updateNote(vaultPath, req.params.path, content);
+  graphEngine.indexNote(vaultPath, note);
+  return res.json({ note });
+});
+
+router.delete('/notes/:path(*)', async (req: Request, res: Response) => {
+  const vaultPath = req.query.vault as string;
+  if (!vaultPath) {
+    return res.status(400).json({ error: 'vault query parameter is required' });
+  }
+  await vaultManager.deleteNote(vaultPath, req.params.path);
+  graphEngine.removeNote(vaultPath, req.params.path);
+  return res.status(204).send();
+});
+
+router.get('/graph', (req: Request, res: Response) => {
+  const vaultPath = req.query.vault as string;
+  if (!vaultPath) {
+    return res.status(400).json({ error: 'vault query parameter is required' });
+  }
+  const graph = graphEngine.getGraph(vaultPath);
+  if (!graph) {
+    return res.status(404).json({ error: 'Graph not found' });
+  }
+  return res.json({ graph });
+});
+
+router.get('/graph/neighbors/:path(*)', (req: Request, res: Response) => {
+  const vaultPath = req.query.vault as string;
+  if (!vaultPath) {
+    return res.status(400).json({ error: 'vault query parameter is required' });
+  }
+  const neighbors = graphEngine.getNeighbors(vaultPath, req.params.path);
+  return res.json({ neighbors });
+});
+
+router.use((err: Error, _req: Request, res: Response, _next: NextFunction) => {
+  console.error('API Error:', err);
+  return res.status(500).json({ error: err.message || 'Internal server error' });
+});
+
+export default router;

package/src/api/themes.ts

@@ -0,0 +1,60 @@
+import express, { Request, Response } from 'express';
+import fs from 'fs/promises';
+import path from 'path';
+
+const THEMES_DIR = path.resolve(process.cwd(), 'data', 'themes');
+
+interface CustomTheme {
+  name: string;
+  variables: Record<string, string>;
+}
+
+async function ensureDir() {
+  await fs.mkdir(THEMES_DIR, { recursive: true });
+}
+
+const router = express.Router();
+
+router.get('/', async (_req: Request, res: Response) => {
+  try {
+    await ensureDir();
+    const files = await fs.readdir(THEMES_DIR);
+    const themes: CustomTheme[] = [];
+    for (const f of files) {
+      if (f.endsWith('.json')) {
+        const data = await fs.readFile(path.join(THEMES_DIR, f), 'utf-8');
+        themes.push(JSON.parse(data));
+      }
+    }
+    res.json({ themes });
+  } catch {
+    res.json({ themes: [] });
+  }
+});
+
+router.post('/', async (req: Request, res: Response) => {
+  const { name, variables } = req.body as CustomTheme;
+  if (!name || !variables) {
+    res.status(400).json({ error: 'name e variables são obrigatórios' });
+    return;
+  }
+  await ensureDir();
+  const filename = name.toLowerCase().replace(/\s+/g, '-') + '.json';
+  await fs.writeFile(
+    path.join(THEMES_DIR, filename),
+    JSON.stringify({ name, variables }, null, 2)
+  );
+  res.status(201).json({ theme: { name, variables } });
+});
+
+router.delete('/:name', async (req: Request, res: Response) => {
+  try {
+    const filename = req.params.name.toLowerCase().replace(/\s+/g, '-') + '.json';
+    await fs.unlink(path.join(THEMES_DIR, filename));
+    res.status(204).send();
+  } catch {
+    res.status(404).json({ error: 'Tema não encontrado' });
+  }
+});
+
+export default router;

package/src/core/graph.ts

@@ -0,0 +1,145 @@
+import { Note, Graph, GraphNode } from '../shared/types.js';
+
+export class GraphEngine {
+  private graphs: Map<string, Graph> = new Map();
+
+  indexNote(vaultPath: string, note: Note): void {
+    let graph = this.graphs.get(vaultPath);
+    
+    if (!graph) {
+      graph = { nodes: [], edges: [], metadata: { totalNotes: 0, totalLinks: 0 } };
+      this.graphs.set(vaultPath, graph);
+    }
+
+    const existingNodeIndex = graph.nodes.findIndex(n => n.id === note.path);
+    const node: GraphNode = {
+      id: note.path,
+      label: note.filename,
+      tags: this.extractTags(note.frontmatter),
+      connections: note.links.length,
+    };
+
+    if (existingNodeIndex >= 0) {
+      graph.nodes[existingNodeIndex] = node;
+    } else {
+      graph.nodes.push(node);
+    }
+
+    const edgeSet = new Set(graph.edges.map(e => `${e.source}-${e.target}`));
+    
+    for (const link of note.links) {
+      const targetPath = link.endsWith('.md') ? link : `${link}.md`;
+      const edgeId = `${note.path}-${targetPath}`;
+      if (!edgeSet.has(edgeId)) {
+        graph.edges.push({
+          id: edgeId,
+          source: note.path,
+          target: targetPath,
+          type: 'wikilink',
+        });
+        edgeSet.add(edgeId);
+      }
+    }
+
+    graph.metadata.totalNotes = graph.nodes.length;
+    graph.metadata.totalLinks = graph.edges.length;
+  }
+
+  removeNote(vaultPath: string, notePath: string): void {
+    const graph = this.graphs.get(vaultPath);
+    
+    if (!graph) return;
+
+    graph.nodes = graph.nodes.filter(n => n.id !== notePath);
+    graph.edges = graph.edges.filter(e => e.source !== notePath && e.target !== notePath);
+    
+    graph.metadata.totalNotes = graph.nodes.length;
+    graph.metadata.totalLinks = graph.edges.length;
+  }
+
+  getGraph(vaultPath: string): Graph | null {
+    return this.graphs.get(vaultPath) || null;
+  }
+
+  getNeighbors(vaultPath: string, notePath: string): GraphNode[] {
+    const graph = this.graphs.get(vaultPath);
+    
+    if (!graph) return [];
+
+    const neighborIds = new Set<string>();
+    
+    for (const edge of graph.edges) {
+      if (edge.source === notePath) {
+        neighborIds.add(edge.target);
+      }
+      if (edge.target === notePath) {
+        neighborIds.add(edge.source);
+      }
+    }
+
+    return graph.nodes.filter(n => neighborIds.has(n.id));
+  }
+
+  getBacklinks(vaultPath: string, notePath: string): GraphNode[] {
+    const graph = this.graphs.get(vaultPath);
+    
+    if (!graph) return [];
+
+    return graph.nodes.filter(n => {
+      return graph.edges.some(e => e.target === notePath && e.source === n.id);
+    });
+  }
+
+  searchByTag(vaultPath: string, tag: string): GraphNode[] {
+    const graph = this.graphs.get(vaultPath);
+    
+    if (!graph) return [];
+
+    return graph.nodes.filter(n => n.tags?.includes(tag));
+  }
+
+  private extractTags(frontmatter: Record<string, unknown> | undefined): string[] {
+    if (!frontmatter) return [];
+    
+    const tags = frontmatter.tags;
+    if (!tags) return [];
+    
+    if (Array.isArray(tags)) {
+      return tags.map(t => String(t));
+    }
+    
+    if (typeof tags === 'string') {
+      return tags.split(',').map(t => t.trim());
+    }
+    
+    return [];
+  }
+
+  computeStats(vaultPath: string): { mostConnected: GraphNode[], orphanNotes: GraphNode[] } {
+    const graph = this.graphs.get(vaultPath);
+    
+    if (!graph) {
+      return { mostConnected: [], orphanNotes: [] };
+    }
+
+    const connectionCounts = new Map<string, number>();
+    
+    for (const edge of graph.edges) {
+      connectionCounts.set(edge.source, (connectionCounts.get(edge.source) || 0) + 1);
+      connectionCounts.set(edge.target, (connectionCounts.get(edge.target) || 0) + 1);
+    }
+
+    const nodesWithCount = graph.nodes.map(n => ({
+      ...n,
+      connectionCount: connectionCounts.get(n.id) || 0,
+    }));
+
+    const mostConnected = nodesWithCount
+      .sort((a, b) => b.connectionCount - a.connectionCount)
+      .slice(0, 10);
+
+    const orphanNotes = nodesWithCount.filter(n => n.connectionCount === 0);
+
+    return { mostConnected, orphanNotes };
+  }
+}

package/src/core/markdown.ts

@@ -0,0 +1,92 @@
+import { marked } from 'marked';
+import fm from 'front-matter';
+import { ParsedNote } from '../shared/types.js';
+
+export class MarkdownParser {
+  constructor() {
+    marked.setOptions({
+      gfm: true,
+      breaks: true,
+    });
+  }
+
+  parse<T extends Record<string, unknown> = Record<string, unknown>>(content: string): ParsedNote<T> {
+    const result = fm<T>(content);
+    
+    return {
+      frontmatter: result.attributes ?? ({} as T),
+      body: result.body,
+      html: marked.parse(result.body) as string,
+      links: this.extractLinks(result.body),
+      headings: this.extractHeadings(result.body),
+    };
+  }
+
+  parseContent(content: string): { frontmatter: Record<string, unknown>, body: string } {
+    const result = fm<Record<string, unknown>>(content);
+    return {
+      frontmatter: result.attributes || {},
+      body: result.body,
+    };
+  }
+
+  extractLinks(content: string): string[] {
+    const links: string[] = [];
+    
+    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 [...new Set(links)];
+  }
+
+  extractHeadings(content: string): Array<{ level: number, text: string, id: string }> {
+    const headings: Array<{ level: number, text: string, id: string }> = [];
+    const headingRegex = /^(#{1,6})\s+(.+)$/gm;
+    
+    let match;
+    while ((match = headingRegex.exec(content)) !== null) {
+      const level = match[1].length;
+      const text = match[2].trim();
+      const id = this.slugify(text);
+      headings.push({ level, text, id });
+    }
+    
+    return headings;
+  }
+
+  slugify(text: string): string {
+    return text
+      .normalize('NFKD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase()
+      .replace(/[^\w\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-')
+      .trim();
+  }
+
+  toMarkdown(note: { frontmatter?: Record<string, unknown>, body: string }): string {
+    let result = '';
+    
+    if (note.frontmatter && Object.keys(note.frontmatter).length > 0) {
+      result += '---\n';
+      for (const [key, value] of Object.entries(note.frontmatter)) {
+        result += `${key}: ${value}\n`;
+      }
+      result += '---\n\n';
+    }
+    
+    result += note.body;
+    return result;
+  }
+}

package/src/core/search.ts

@@ -0,0 +1,208 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { existsSync } from 'fs';
+
+interface InvertedIndex {
+  [term: string]: {
+    [notePath: string]: number;
+  };
+}
+
+export interface SearchDoc {
+  path: string;
+  filename: string;
+  content: string;
+  tags: string[];
+  modified: string;
+  backlinks: number;
+}
+
+export interface SearchResult {
+  path: string;
+  filename: string;
+  snippet: string;
+  score: number;
+  tags: string[];
+  modified: string;
+  backlinks: number;
+}
+
+const STOPWORDS = new Set([
+  'de', 'da', 'do', 'das', 'dos', 'a', 'o', 'e', 'em', 'para', 'com',
+  'um', 'uma', 'uns', 'umas', 'no', 'na', 'nos', 'nas', 'ao', 'aos',
+  'à', 'às', 'pelo', 'pela', 'pelos', 'pelas', 'que', 'se', 'por',
+  'como', 'mais', 'mas', 'ou', 'entre', 'sem', 'sua', 'seu', 'seus',
+  'suas', 'meu', 'minha', 'teu', 'tuas', 'nosso', 'nossa', 'isto',
+  'isso', 'aquilo', 'este', 'esta', 'esse', 'essa', 'aquele', 'aquela',
+  'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can',
+  'had', 'her', 'was', 'one', 'our', 'out', 'has', 'have', 'been',
+  'some', 'them', 'than', 'that', 'this', 'very', 'were', 'will',
+  'with', 'from', 'they', 'what', 'when', 'where', 'which', 'who',
+  'how', 'its', 'also', 'into', 'over', 'then', 'many', 'each',
+  'would', 'could', 'should', 'about', 'there', 'their', 'other',
+]);
+
+const PUNCTUATION = /[^\w\s]/g;
+const WHITESPACE = /\s+/g;
+
+function normalize(text: string): string {
+  return text
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase();
+}
+
+function tokenize(text: string): string[] {
+  const cleaned = normalize(text).replace(PUNCTUATION, ' ').replace(WHITESPACE, ' ');
+  return cleaned.split(' ').filter(t => t.length > 1 && !STOPWORDS.has(t));
+}
+
+function highlightSnippet(text: string, queryTerms: string[], maxLen = 160): string {
+  const lower = normalize(text);
+  let bestIdx = 0;
+  let bestScore = 0;
+
+  for (const term of queryTerms) {
+    const idx = lower.indexOf(term);
+    if (idx >= 0) {
+      const proximity = queryTerms.reduce(
+        (acc, t) => acc + (lower.indexOf(t, Math.max(0, idx - 40)) >= 0 ? 1 : 0),
+        0
+      );
+      if (proximity > bestScore) {
+        bestScore = proximity;
+        bestIdx = idx;
+      }
+    }
+  }
+
+  let start = Math.max(0, bestIdx - 60);
+  let end = Math.min(text.length, start + maxLen);
+  if (start > 0) start = text.indexOf(' ', start - 20) + 1 || start;
+  if (end < text.length) end = text.lastIndexOf(' ', end) || end;
+
+  let snippet = text.slice(start, end);
+  for (const term of queryTerms) {
+    const regex = new RegExp(`(${escapeRegex(term)})`, 'gi');
+    snippet = snippet.replace(regex, '<mark>$1</mark>');
+  }
+  return snippet;
+}
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function computeTF(terms: string[]): Map<string, number> {
+  const freq = new Map<string, number>();
+  for (const t of terms) freq.set(t, (freq.get(t) || 0) + 1);
+  const maxFreq = Math.max(...freq.values(), 1);
+  for (const [k, v] of freq) freq.set(k, v / maxFreq);
+  return freq;
+}
+
+export class FullTextIndexer {
+  private index: InvertedIndex = {};
+  private docCount = 0;
+  private indexDir: string;
+
+  constructor(indexDir = './data/search-index') {
+    this.indexDir = indexDir;
+  }
+
+  async load(): Promise<void> {
+    try {
+      const filePath = path.resolve(this.indexDir, 'index.json');
+      if (!existsSync(filePath)) return;
+      const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+      this.index = data.index || {};
+      this.docCount = data.docCount || 0;
+    } catch {
+      this.index = {};
+      this.docCount = 0;
+    }
+  }
+
+  async save(): Promise<void> {
+    await fs.mkdir(this.indexDir, { recursive: true });
+    await fs.writeFile(
+      path.join(this.indexDir, 'index.json'),
+      JSON.stringify({ index: this.index, docCount: this.docCount }, null, 2)
+    );
+  }
+
+  indexNote(note: SearchDoc): void {
+    const text = `${note.filename} ${note.content} ${(note.tags || []).join(' ')}`;
+    const terms = tokenize(text);
+    const tf = computeTF(terms);
+
+    for (const [term, freq] of tf) {
+      if (!this.index[term]) this.index[term] = {};
+      this.index[term][note.path] = freq;
+    }
+    this.docCount = Object.keys(
+      Object.values(this.index).reduce(
+        (acc, t) => { Object.keys(t).forEach(k => { (acc as Record<string, boolean>)[k] = true; }); return acc; },
+        {} as Record<string, boolean>
+      )
+    ).length;
+  }
+
+  removeNote(notePath: string): void {
+    for (const term of Object.keys(this.index)) {
+      delete this.index[term][notePath];
+      if (Object.keys(this.index[term]).length === 0) delete this.index[term];
+    }
+  }
+
+  search(query: string, allNotes: SearchDoc[], filters?: {
+    tag?: string;
+    after?: string;
+    before?: string;
+    hasBacklinks?: boolean;
+  }): SearchResult[] {
+    const queryTerms = tokenize(query);
+    if (queryTerms.length === 0) return [];
+
+    const idf = (term: string): number => {
+      const df = Object.keys(this.index[term] || {}).length;
+      return df > 0 ? Math.log(1 + (this.docCount - df + 0.5) / (df + 0.5)) + 1 : 0;
+    };
+
+    const docScores = new Map<string, number>();
+    for (const term of queryTerms) {
+      const postings = this.index[term];
+      if (!postings) continue;
+      const weight = idf(term);
+      for (const [docPath, tf] of Object.entries(postings)) {
+        docScores.set(docPath, (docScores.get(docPath) || 0) + tf * weight);
+      }
+    }
+
+    const noteMap = new Map(allNotes.map(n => [n.path, n]));
+
+    const results: SearchResult[] = [];
+    for (const [docPath, score] of docScores) {
+      const note = noteMap.get(docPath);
+      if (!note) continue;
+
+      if (filters?.tag && !note.tags.includes(filters.tag)) continue;
+      if (filters?.after && note.modified < filters.after) continue;
+      if (filters?.before && note.modified > filters.before) continue;
+      if (filters?.hasBacklinks === true && note.backlinks === 0) continue;
+      if (filters?.hasBacklinks === false && note.backlinks > 0) continue;
+
+      results.push({
+        path: note.path,
+        filename: note.filename,
+        snippet: highlightSnippet(note.content, queryTerms),
+        score,
+        tags: note.tags,
+        modified: note.modified,
+        backlinks: note.backlinks,
+      });
+    }
+
+    return results.sort((a, b) => b.score - a.score);
+  }
+}