This repository is a local-first, source-cited knowledge base management system, delivered primarily as a Claude Code plugin and a standalone Python CLI tool. It manages Obsidian vaults with a strong emphasis on data integrity, provenance tracking, and deterministic operations. The architecture is a monolithic Python library (`claude_obsidian/`) with a formal transaction system for all vault mutations, a robust lint engine, and a retrieval pipeline (BM25 + optional semantic reranking). It features a sophisticated skill/agent framework for AI integration across multiple hosts (Claude, Cursor, Windsurf, etc.). While primarily an application, it incorporates significant data engineering and research data management (RDM) patterns. The provenance ledger system (`ledgers.py`) enforces strict schemas for sources and claims, including canonical URL handling, content-addressed identity, and evidence validation rules. The retrieval pipeline implements Anthropic's Contextual Retrieval pattern. This hybrid nature makes it a powerful tool for both knowledge management and structured research workflows. The codebase demonstrates exceptionally high craftsmanship in its transaction system, defensive I/O, and deterministic analysis tools. It is actively maintained with a comprehensive test suite and a formal release process. Its primary limitation is platform dependency on Linux/macOS for write operations (WSL required for Windows).
Khoj is an open-source personal AI assistant functioning as a 'second brain' for interacting with personal knowledge bases. It provides a chat interface allowing users to converse with various AI models about documents, notes, and connected data sources (local files, GitHub, Notion). The system supports multimodal capabilities including image generation, code execution, voice input/output, and computer operation through a modular agent architecture. Khoj features a Python/Django backend with FastAPI for API endpoints, a PostgreSQL database with pgvector for vector storage and search, and multiple frontends including a web application (React/Next.js), desktop client (Electron), mobile app (Android), and plugins for Obsidian and Emacs. The architecture emphasizes separation of concerns with distinct modules for file processing, embedding generation, conversation handling, tool integration, and user management.
PDFMathTranslate is a production-grade CLI and GUI application for translating PDF documents while preserving scientific formatting (formulas, charts, tables, and fonts). It uses an ONNX-based layout detection model (DocLayout-YOLO) to understand document structure, supports OCR for scanned PDFs, and integrates with numerous translation services (Google, DeepL, OpenAI, Ollama, etc.). The system operates as a monolithic package with multiple entry points: a command-line tool, a Gradio web interface, a Flask+ Celery HTTP API, and an MCP server for AI assistant integration. Internally, it follows a pipeline architecture: input PDF → optional OCR → layout analysis → text extraction → translation (with caching) → typesetting → bilingual output PDF. Notable engineering patterns include a pluggable translation backend via a kernel registry, a configurable translator base class with retry and caching, and a singleton configuration manager. The code is well-structured with test coverage and CI/CD pipelines, though the dependency on a Git submodule for the 'precise' kernel introduces minor coupling risk.
Defuddle is a content extraction library that converts web pages into clean, readable Markdown with structured metadata (title, author, site, published date). It is the engine behind the Obsidian Web Clipper browser extension and also runs as a standalone CLI tool, an npm package, and a hosted API service on Cloudflare Workers. The architecture follows a modular pipeline: fetch HTML, detect site-specific extractors, score and select main content, remove clutter (nav, ads, sidebars), standardize complex elements (footnotes, math, code blocks, images), and convert to Markdown via Turndown. The library is designed as a more forgiving alternative to Mozilla's Readability, with support for mobile-style heuristics, schema.org metadata extraction, and extensive site-specific extractors for platforms like YouTube, Reddit, Twitter/X, ChatGPT, GitHub, and Gmail. The codebase is written in TypeScript and produces three bundles: core (browser, no extra dependencies), full (adds MathML-to-LaTeX conversion), and node (accepts any DOM implementation). The CLI uses Commander and supports file, URL, and stdin input with options for Markdown, JSON, frontmatter, and debug output. The hosted API runs on Cloudflare Workers with Stripe-based billing, rate limiting, and Durable Objects for stateful API key management. The test suite is exceptionally comprehensive, with hundreds of HTML fixtures and expected Markdown outputs covering edge cases from dozens of real-world websites, CMS patterns, and syntax highlighters. Key external dependencies include Turndown (Markdown conversion), linkedom (DOM parsing in Node.js), mathml-to-latex and Temml (math rendering), and various third-party APIs for site-specific extractors (YouTube InnerTube, FxTwitter, Reddit Atom feeds, Bilibili). The project maintains strict security practices: no innerHTML assignments outside a single utility function, URL sanitization, and XSS prevention through template-based HTML parsing. The build system uses webpack with aliases for math module switching and enforces bundle size budgets via CI scripts.
This Obsidian plugin enables users to make HTTP API requests directly from within their notes using markdown code blocks. It processes 'req' language blocks to execute GET, POST, PUT, DELETE, PATCH, HEAD, and OPTIONS requests, with support for variable substitution from frontmatter, global variables, and cached responses. The plugin emphasizes security through comprehensive input validation, URL sanitization, JSONPath expression validation, and XSS prevention in output formatting. The architecture separates concerns between the main request processing logic, security utilities, and Obsidian-specific integration points. Key features include response caching via localStorage with unique identifiers, automatic variable resolution, JSONPath-based data extraction, customizable output formatting, and the ability to save responses to files or update frontmatter properties. The plugin implements defense-in-depth security practices to protect against common web vulnerabilities while providing a flexible API integration tool for knowledge workers.
Eleventy Notes is a highly opinionated static site generator template built on top of Eleventy (11ty). It is designed for publishing personal notes, documentation, wikis, or blogs with a focus on rich interlinking, client-side search, and customization. The system is a static site generator that processes Markdown files into a fully featured website. It includes a modular architecture with core infrastructure (layout, header, sidebar), and modules for wikilinks, callouts (admonitions), tags, custom properties, dynamic content queries, table of contents, search (using Pagefind), bookmarks, theming, translations, and page navigation. The build process uses Parcel for CSS/JS bundling and Eleventy for HTML generation. The application is designed to be configured via a single JavaScript file (`app.mjs`) and a SCSS file (`app.scss`). The code is well-structured, uses ES modules, and demonstrates advanced patterns such as custom markdown-it plugins, a generic query engine, and a tree generator. It is a template intended for end users to fork and customize, but the underlying codebase itself exhibits high craftsmanship and could serve as a reference for building Eleventy-based projects.
obsidian.nvim is a Neovim plugin that integrates Obsidian vault functionality directly into Neovim. It provides note creation, linking, completion, navigation, image handling, synchronization, and templating features for markdown-based notes. The plugin leverages Neovim's API for LSP integration, autocommands, buffer management, and picker interfaces (telescope, fzf, snacks, mini) to deliver an Obsidian-like experience within Neovim. It maintains a cache of note metadata for performance and supports multiple workspaces with per-workspace overrides. The architecture is modular, separating concerns into commands, LSP handlers, note management, workspace handling, caching, search, picker abstraction, and completion sources.
This repository is a CSS theme for the Obsidian note-taking application, designed to replicate the visual aesthetic of the Things 3 task manager. The codebase consists of a single `theme.css` file that overrides Obsidian's default styling using CSS custom properties, class overrides, and media queries. It provides both light and dark color schemes, custom checkbox icons via CSS mask images, progress bar coloring based on percentage, and extensive integration with community plugins like Kanban, Calendar, Todoist, and Checklist. The theme also includes a comprehensive set of user-customizable settings exposed through the Style Settings plugin. This is a pure presentation layer with no application logic, data processing, or dependencies beyond Obsidian itself.
This is an Obsidian plugin that extends the built-in `obsidian://` URI scheme with additional `x-callback-url` endpoints for automation. It provides a modular routing system with endpoints for notes (CRUD, append/prepend, search/replace, touch), files, folders, vault info, commands, search, Dataview queries, Omnisearch, tags, and note properties. The architecture is modular: each route is defined in its own file under `src/routes/`, with Zod schemas for parameter validation and handler functions that return standardized success/failure objects. The main entry point is `src/main.ts`, which registers URI handlers and manages plugin lifecycle. Incoming URIs are matched to routes, parameters are validated and transformed (e.g., resolving file paths, UIDs, periodic notes), and the handler executes the requested action, sending callbacks via `x-success`/`x-error` URLs. External dependencies include the Obsidian API, Zod, `obsidian-daily-notes-interface`, `obsidian-dataview`, and `filter-obj`. The plugin also relies on third-party plugins (Templater, Periodic Notes, Dataview, Omnisearch) for certain routes. The codebase is well-structured with TypeScript, esbuild bundling, Jest E2E tests using a custom callback server, and comprehensive documentation.
Joplin is a mature, cross-platform note-taking and synchronization application built on a monorepo architecture using Yarn Workspaces. It comprises four primary application layers: a desktop client (Electron/React), a mobile client (React Native), a CLI tool (Node.js), and a self-hosted server (Node.js/Koa). The core business logic resides in `packages/lib`, which handles data models (Notes, Folders, Tags), encryption (E2EE), and synchronization protocols (WebDAV, Joplin Server, Dropbox, etc.). The codebase demonstrates strong engineering practices with TypeScript, Redux state management, and a robust plugin system that allows third-party extensibility via a defined API. It supports multiple editor backends (CodeMirror, ProseMirror, TinyMCE) and integrates native modules for performance-critical tasks like OneNote parsing (Rust) and voice transcription (Whisper).
The Obsidian Web Clipper is a browser extension that enables users to clip web content and save it as markdown notes in their Obsidian vault. It features a modular architecture with background scripts, content scripts, popup UI, and settings pages, plus a CLI component. The extension provides highlighting, reader mode, template-based formatting with variables and filters, AI-powered content processing, and cross-browser support for Chrome, Firefox, and Safari. Data flows from user interaction through the popup UI to content scripts that extract and process webpage data, which is then formatted via a template engine and saved to Obsidian. The system relies on webextension-polyfill for cross-browser compatibility, defuddle for content extraction, and various UI libraries for functionality.
Remindian is a macOS menu bar application that synchronizes tasks between Obsidian (as the source of truth) and various task management systems including Apple Reminders, Things 3, Todoist, TickTick, Asana, Linear, and Calendar Feed. The app allows users to configure multiple sync profiles, each connecting a source (Obsidian Vault, TaskNotes, or Generic Markdown) to a destination task service. It runs in the background with manual or scheduled synchronization, provides UI for configuration and monitoring, and includes safety features like automatic backups before file modifications, audit logging, and conflict resolution where Obsidian always wins as the source of truth. The architecture follows a layered pattern with SwiftUI for the presentation layer, a service layer for platform-specific integrations, a model layer for data structures, and protocol-based abstractions (TaskSource/TaskDestination) that enable pluggable implementations. The SyncManager acts as the central coordinator, while the SyncEngine orchestrates the synchronization process. Key features include bidirectional sync with configurable directions, duplicate detection, natural language task entry, and extensive customization options for field mapping and filtering. The application demonstrates strong engineering practices with a comprehensive test suite, careful attention to data integrity through surgical file edits and backup systems, and thoughtful handling of platform-specific integrations. While deeply integrated with macOS and specific task services, it maintains clean separation of concerns through its protocol-oriented design, making core components potentially reusable in other synchronization contexts.
This repository is the Meta Bind plugin for Obsidian, a note-taking application. It allows users to embed interactive input fields, view fields, buttons, and tables directly into Markdown notes, bound to frontmatter metadata or in-memory data. The plugin parses a custom DSL (e.g., `INPUT[type: text]`, `VIEW[...]`, `BUTTON[...]`) using a custom parser library (parsinom) and renders Svelte components that read and write metadata values. It supports over 20 input field types (text, number, slider, toggle, select, date, etc.), view fields with math expressions and markdown rendering, and button actions (commands, JS execution, note creation, metadata updates, etc.). The architecture is a monorepo with three packages: `core` (platform-independent logic), `obsidian` (Obsidian desktop adapter), and `publish` (Obsidian Publish adapter). The core package contains all parsing, configuration, field implementations, metadata management, and Svelte UI components. The obsidian package integrates with Obsidian's plugin API, CodeMirror editor, and metadata cache. The publish package provides a limited subset for Obsidian Publish. In production, the plugin operates as a Markdown post-processor and a CodeMirror view plugin. When a note is rendered, it scans for DSL declarations, parses them into field configurations, creates mountable field components, and binds them to metadata sources (frontmatter, YAML, in-memory caches). Changes in input fields propagate back to metadata and trigger updates to other bound fields. The plugin also provides a public API for other plugins (e.g., JS Engine) to create fields programmatically. External dependencies include Obsidian's own API, and optional integrations with the Dataview, Templater, and JS Engine plugins. The codebase demonstrates strong software engineering practices: clean separation of concerns, extensive use of factory and strategy patterns, a reactive metadata subscription system, and a comprehensive test suite. However, there are signs of technical drift such as commented-out code, some type safety workarounds, and a large parameterized test file that is difficult to maintain. Overall, it is a well-crafted, feature-rich plugin with reusable components that could be extracted for other projects.
chubbyskills is a personal knowledge management CLI toolkit that ingests content from over a dozen platforms (YouTube, Bilibili, X, Xiaohongshu, WeChat, Douyin, Podcasts, etc.), transcribes audio/video locally or via cloud providers, and outputs structured Markdown notes with YAML frontmatter (schema v1). The system is architected as a collection of modular "skills" (one per platform) orchestrated by a unified CLI (`tools/chubby.py`), with shared utilities in `chubby_common/`. It includes an incremental knowledge base indexer using SQLite FTS5 and optional semantic embeddings, an MCP server exposing six tools for AI agent integration, and a deterministic evidence brief generator with integrity validation. Operation is local-first: transcription uses SenseVoice and faster-whisper, video downloading uses yt-dlp, and all processing is designed to work offline. Cloud transcription (Atlas/MuAPI) and LLM enrichment (DeepSeek) are optional extensions. The repository also provides a skill installer, platform smoke testing, output validation, and retry mechanisms with credential redaction. Despite the breadth, the codebase maintains clean separation of concerns, with the shared library standing out as a reusable zero-dependency core.
TidGi-Desktop is a cross-platform Electron application that integrates TiddlyWiki (a personal wiki) with AI agent capabilities, Git synchronization, and modern desktop features. It allows users to manage multiple workspaces (folder-based or single-file HTML wikis), sync with Git remotes, and interact with AI agents for chat, tool execution, and knowledge management. The architecture is Electron multi-process with main process, renderer processes (multiple windows), and a utility process for wiki worker. Services are wired via Inversify DI container and communicate via typed IPC (electron-ipc-cat). Key entry points include src/main.ts (Electron main), src/renderer.tsx (React renderer), src/services/agentInstance/ (AI agent lifecycle), src/services/wiki/ (wiki management), and src/services/git/ (Git operations). External dependencies include TiddlyWiki, Git (via dugite), SQLite (TypeORM), various AI SDKs (OpenAI, Anthropic, etc.), OAuth providers, and system-level integrations. The codebase is well-structured with a service-oriented architecture, extensive test coverage (unit, E2E, BDD), and a rich preference system driven by Zod schemas. It demonstrates high craftsmanship in areas like AI prompt concatenation, tool registration, and file system watching, though some modules are tightly coupled to the application's domain.
This is an Obsidian plugin that integrates large language models (LLMs) directly into the note-taking environment. It provides a template-driven text generation system using Handlebars with custom async helpers, supports multiple LLM providers (OpenAI, Anthropic, Google Gemini, Mistral, Ollama, Perplexity, HuggingFace, Together AI, MiniMax, Azure, and custom endpoints), and offers content extraction from PDF, audio, images, YouTube, RSS, and web pages. The plugin includes a community template marketplace, auto-suggest, an overlay toolbar, a playground for testing templates, and extensive Obsidian integration (commands, views, settings, CodeMirror extensions). Architecturally, it is a client-side monolithic plugin that communicates directly with external LLM APIs and the npm registry for package management. The codebase is large (300+ files) and well-organized into providers, extractors, UI components, and services, but it shows some drift due to hard-coded model lists and deprecated provider support (e.g., Google PaLM). The async Handlebars helpers and generic caching utility are highlight components that could be extracted for reuse in other projects.
feedgrab is a universal content aggregation tool that fetches, normalizes, and saves content from 18+ platforms (Twitter/X, Xiaohongshu, WeChat, YouTube, Bilibili, GitHub, HackerNews, Medium, Reddit, Weibo, Douyin, Telegram, RSS, Feishu, Kdocs, Zsxq, FlowUs, and more) into Obsidian-compatible Markdown files with YAML frontmatter. It operates as a CLI tool, a Python library, and an MCP server, featuring a modular architecture with per-platform fetchers that implement a multi-tier fallback strategy (direct API → CDP browser reuse → Playwright launch → Jina Reader) to maximize resilience against anti-scraping measures. The system includes robust utilities for deduplication, media download, Groq Whisper transcription, paywall bypass, and cookie rotation for authenticated platforms. Originally developed as a 'vibe coding' personal project, it has evolved into a well-structured application with a service layer, typed configuration, and comprehensive CLI commands (login, doctor, batch search, setup wizard). It is actively maintained, with frequent commits addressing platform API changes and adding new features.
Jimmy is a command-line and terminal UI tool for converting notes from 50+ note-taking applications (Evernote, Obsidian, Joplin, Notion, Bear, etc.) into a unified Markdown format. It uses an intermediate representation (Notebook/Note/Resource/Tag objects) decoupled from input parsing and output writing, allowing clean extensibility. The architecture is a plugin-style converter framework with a rich set of format-specific parsers, markdown preprocessing libraries, and a resource deduplication system. The tool is distributed as standalone binaries bundling Pandoc and other dependencies. While the core abstractions are well-crafted, the vast majority of the codebase consists of tightly coupled format converters that are specific to each app's export schema, limiting general reuse. The project has extensive integration tests via a test data submodule, but many converters lack unit tests. Its requirement for Python 3.14 (a very recent version) and reliance on external binaries (Pandoc, one2html) introduce drift risks.
LapisCV is a collection of Markdown-based resume templates and styling assets designed for use with Obsidian, Typora, and VSCode. It provides a base CSS file (main.css) that defines the core resume styling using CSS variables for easy theming, along with platform-specific overrides to adapt to each editor's rendering engine. Users edit the provided Markdown templates to create their resumes and export to PDF using their editor's built-in or plugin-based PDF export functionality. The project includes a Makefile to build distribution packages for each supported platform.
This repository contains the official developer documentation for the Obsidian note-taking application. It is structured as an Obsidian vault with Markdown files, auto-generated TypeScript API reference pages, hand-written CSS variable references, and guides for plugin and theme development. The documentation is published as a static site via Obsidian Publish using a GitHub Actions workflow. The repo includes a build pipeline (api-extractor, api-documenter, custom post-processing) that generates the API reference from the Obsidian TypeScript API definitions. While the documentation itself is comprehensive and well-organized, the build tooling has some fragility (hardcoded paths, regex-based transformations) and the generated API pages are not directly editable. The repo serves as the primary resource for third-party developers building plugins and themes for Obsidian.