$ show we-promise/sure
This is a large, actively maintained Ruby on Rails 8.1 monolith serving as a self-hostable personal finance management platform (a community fork of Maybe Finance). Its architecture is a classic MVC monolith with a Hotwired Turbo/Stimulus frontend, a Sidekiq background job layer, and a REST API consumed by Tauri desktop and Flutter mobile clients. The system is built around a PostgreSQL database with extensive use of UUIDs, JSONB, and pgvector for AI features. The core functionality revolves around aggregating financial data from over 20 external providers (Plaid, SimpleFin, Coinbase, etc.) using a sophisticated, extensible adapter pattern. It provides comprehensive budgeting, investment tracking, net worth calculations, bill management, and a powerful rule engine for automating transaction categorization and enrichment. A standout feature is its integrated AI assistant, which leverages OpenAI and Anthropic models for natural language queries, auto-categorization, and financial insights, backed by a structured evaluation framework. The codebase demonstrates exceptionally high craftsmanship in several areas. The Provider adapter pattern, Rule Engine, and AI Assistant framework are all cleanly abstracted, loosely coupled, and highly reusable. The custom Design System (DS:: components) provides a consistent, accessible UI toolkit. The balance calculation engine and financial modeling code show deep domain expertise. While the sheer number of provider integrations introduces some duplication, the core architectural patterns are genuinely exceptional and worth studying. The project is actively maintained with frequent commits, extensive CI/CD, and a large community. Technical drift is low, as the codebase actively migrates to modern libraries (e.g., GoodJob to Sidekiq) and adapts to provider API changes. The primary risks are the operational complexity of managing 20+ provider integrations and the dependency on external LLM APIs for AI features.
The LLM identified 5 files worth highlighting for reuse:
A highly sophisticated, extensible adapter pattern for integrating external financial data sources. Provider::Base defines the interface, Provider::Registry manages registration, and Provider::Factory instantiates the correct adapter. Each adapter (e.g., PlaidAdapter, SimplefinAdapter) implements a standard set of methods (sync, build_provider, connection_configs). This pattern is cleanly abstracted, loosely coupled, and could be extracted to build a generic financial data aggregation library. It demonstrates deep understanding of polymorphism and interface design in Ruby.
A generic, extensible rule engine applied to financial transactions. It uses a registry pattern (Rule::Registry) to discover conditions and actions. Conditions are evaluated against a resource (e.g., a Transaction), and matching rules execute their actions (e.g., set category, send email). The architecture is cleanly separated, testable, and could be extracted for any domain requiring user-defined business rules. The use of Rule::ConditionFilter and Rule::ActionExecutor subclasses demonstrates a strong grasp of the Strategy pattern.
A robust framework for building an LLM-powered assistant with function calling. Assistant::Base manages conversation state. Assistant::Function provides a base class for defining tools with JSON schemas, strict mode, and pagination. The Responder orchestrates the LLM call and function execution. This is a non-trivial, well-architected pattern for integrating LLMs into a transactional application, handling streaming, tool calls, and history trimming. It is highly reusable for any application wanting to add an AI agent.
A sophisticated engine for calculating account balances over time. It handles forward and reverse calculations, series aggregation, and caching. This is a core financial domain problem solved with clean mathematical abstractions. It is isolated from the web framework and could be extracted as a library for financial calculations.
A comprehensive, custom-built design system using ViewComponent and Tailwind CSS. Components like DS::Button, DS::Dialog, DS::Table, and DS::Tooltip are fully featured with ARIA support, variants, and test coverage. This demonstrates a high level of front-end craftsmanship and provides a reusable UI toolkit that is framework-agnostic on the backend (Rails) but could be adapted.