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).
Logseq is a privacy-first, open-source knowledge management platform built as a monorepo containing an Electron desktop app, Capacitor-based mobile apps (iOS/Android), a web app, and a Node.js db-sync server. The codebase is predominantly ClojureScript (CLJS) with React/Rum for the UI, DataScript for the in-memory graph database, and SQLite (via better-sqlite3 and sqlite-wasm) for persistence. It uses shadow-cljs for CLJS compilation, webpack for JS bundling, and Tailwind CSS for styling. A separate OCaml-based CLI (logseq-cli) built with Melange provides graph inspection, sync, and CRUD operations against the same db-worker-node backend. The architecture separates concerns into deps/ subprojects (db, outliner, graph-parser, db-sync, common, publishing, shui) that are compiled as separate shadow-cljs targets and shared across Electron, browser, mobile, and CLI runtimes. The system has two graph types: file-based graphs (Markdown/Org) and DB graphs (SQLite-backed with DataScript in-memory querying). DB graphs enable real-time collaboration (RTC) via a Cloudflare Worker-based sync server (deps/db-sync) using WebSockets and D1 SQLite. The db-worker-node is a long-lived Node.js process that manages SQLite connections and sync state, communicating with the UI via a thread-api IPC mechanism. The outliner module handles block tree operations with structural invariants, while the graph-parser handles Markdown/Org parsing via mldoc. The publishing module generates static HTML sites from graphs. Key architectural patterns include: missionary for reactive async flows, promesa for promise composition, malli for schema validation, datascript for Datalog queries, and a component-based UI with Rum/React. The codebase has extensive test coverage via cljs.test, Playwright E2E tests (clj-e2e), and Python-based CLI E2E tests (cli-e2e). The repository is actively maintained with recent commits, 43k+ stars, and active issue triage, though the large monorepo complexity and multi-language surface (CLJS, OCaml, Swift, Kotlin, Python, JS) create maintenance challenges.
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.
GistPad MCP is a Model Context Protocol (MCP) server that provides a comprehensive interface for managing GitHub Gists through AI assistants like GitHub Copilot and Claude Desktop. It exposes tools for CRUD operations on gists, file management within gists, comments, daily notes, archiving, starring, and reusable prompts. The server runs over stdio and uses the GitHub REST API via a custom typed fetch client. It features a caching layer with hourly refresh, resource subscriptions, and change notifications. The codebase is written in modern TypeScript (ES2024, Node.js 22+) with strict type safety, comprehensive tests for the file editing tool, and a clean modular architecture separating concerns into tools, server, store, and utilities. It demonstrates strong engineering practices including abstract base classes for stores, automatic tool annotation derivation, and careful error handling.
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.
Promnesia is a browser extension (Chrome/Firefox) paired with a Python backend that enriches browsing history with contextual metadata from personal data sources. The backend indexes visits from browser history, bookmarks, chat logs (Telegram, Signal, etc.), social media (Reddit, Twitter, Hacker News), note-taking apps (Hypothesis, Pocket, Instapaper), and plaintext files into a SQLite database. A FastAPI server exposes endpoints (`/visits`, `/search`, `/visited`) that the extension queries to annotate visited links and display a sidebar with visit context, timestamps, and highlights. The system uses URL normalization (canonical URLs) to deduplicate visits across sources and supports user-defined filtering and hooks. The architecture is split into a Python CLI (`promnesia index` / `promnesia serve`), a TypeScript browser extension built with Rollup, and Docker containers for automated indexing. While the core is a personal data application, it also serves as a data pipeline for aggregating and querying personal activity, giving it a hybrid character.
Make.md is an Obsidian plugin (manifest id `make-md`) that turns a plain vault into a structured knowledge workspace. In production it registers custom leaf views (Spaces, Navigator, Blink), patches Obsidian's workspace and CodeMirror editor, and maintains a metadata layer called `Superstate` indexed by web workers. It ships a React-based frame layout engine where notes/spaces are rendered as configurable frame trees with style/action expressions evaluated at runtime, an MDB layer that reads and writes SQLite `.mdb` files via sql.js, and a predicate/filter/aggregate system powering table, calendar, list, and chart views. The plugin also includes a custom mathjs-based formula language, an HTML export pipeline, and a D3-driven visualization pipeline.