Uwi0/Oakane

Oakane is a cross-platform personal finance application built with Kotlin Multiplatform that enables users to track income and expenses across multiple wallets, set monthly budgets with category limits, and manage savings goals. The system provides a comprehensive suite of features including transaction logging with receipt image attachments, detailed financial reporting with data visualization, and robust data portability through JSON backup and restore capabilities. It supports both Android and iOS platforms with native UI implementations while sharing core business logic, data models, and database schemas.

109 changes.

The project underwent a major architectural restructuring to a multi-module Kotlin Multiplatform setup, introducing Koin dependency injection and SQLDelight for shared data persistence. This foundation enabled the parallel development of comprehensive financial features, including home dashboards, transaction management, goal tracking, and budgeting, across both Android and iOS platforms. The period also saw the establishment of robust design systems and UI components for both platforms to support these new capabilities.

50 changes.

This period established the foundational multi-platform architecture by introducing dedicated modules for models, data, domain logic, and cross-platform preferences. It simultaneously delivered the complete user onboarding experience, including account setup, backup restoration, and wallet creation flows for both Android and iOS. The work also implemented core financial features such as wallet management, transaction logging, and recurring budget reminders.

The Android-specific Reports screen is now available, allowing users to view financial summaries via a donut chart and itemized lists, filter reports by specific wallets, and export data as CSV files directly to the device's Downloads folder. The screen integrates with the navigation system to support drawer visibility states and handles report generation events by saving the generated file with a timestamped filename.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/reports · high confidence

Users can now create new wallets or edit existing ones on Android via a dedicated screen. This feature allows setting a wallet name, initial balance, and visual customization (icon and color) using bottom sheets, and supports navigation from the onboarding flow or from the main app.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/createwallet · high confidence

The Android presentation layer now includes a dedicated Wallets screen that displays a list of wallets using a ViewModel-driven state model, featuring a top app bar, a scrollable list of wallet items, and a floating action button to initiate wallet creation. Navigation to this screen is wired up via a new route definition, allowing users to access the wallet management interface from the app's main navigation graph.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/wallets · high confidence

A new CardNoteView component has been added to the design system, providing a reusable UI element to display optional notes associated with a card. This view renders a 'Note' label followed by the note content, defaulting to a hyphen if the note is empty, and applies the standard surface background styling.

iosApp/iosApp/designSystem/component/card · high confidence

A new SwiftUI view, CreateWalletSheetView, has been introduced in the design system's sheet component to handle the creation of new wallets. This view provides a user interface for entering a wallet name, setting an initial balance, selecting an icon, and choosing a color, culminating in an 'Add Wallet' action that triggers the state's save logic.

iosApp/iosApp/designSystem/ui/sheet · high confidence

The Add Goal screen now uses a dedicated shared ViewModel (AddGoalViewModel) and contract (AddGoalViewContract) to manage state and interactions. Users can now create new goals and edit existing ones, with the system automatically loading the current currency and goal details when editing. The feature handles saving goal data (name, target amount, dates, notes) and provides feedback on success or errors, replacing the previous implementation that relied on simple lambda expressions.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/addGoal · high confidence

The Android-specific UI for creating and editing goals has been implemented in AddGoalScreen.kt. This screen allows users to select a goal image, input a target amount using a localized currency text field, enter a goal name and optional notes, and set start and end dates via a date picker. The interface integrates with the AddGoalViewModel to handle state, events, and navigation, providing a complete user flow for goal management on Android.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/addGoal · high confidence

The iOS app now includes a dedicated screen for creating and editing financial goals. This new AddGoalScreen allows users to input a goal name, target amount, note, and start/end dates, and select an image. The screen is backed by a new AddGoalViewModel that manages the UI state and handles events such as saving the goal, navigating back, or displaying errors.

iosApp/iosApp/screen/addGoal · high confidence

The Add Goal feature is now accessible via a dedicated navigation route. Users can navigate to the Add Goal screen by providing a specific goal ID, which is passed as a path argument to the AddGoalRoute component. This change establishes the navigation entry point for creating or updating goals within the application.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/addGoal/navigation · high confidence

Users can now view and accept the app's terms and conditions before proceeding. This new screen displays four distinct agreement items with checkboxes, includes a link to the project's GitHub repository, and features a button that becomes enabled once all terms are accepted, navigating users to the onboarding flow upon completion.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/termAndService, shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/termAndService · high confidence

Users can now attach images to transactions via a new gallery picker, select specific dates using a date picker, and filter transaction categories by name or type (income/expense) within a dedicated sheet. These new UI components (ButtonPickImage, DateButtonView, CategoriesSheetView, CategoryButtonView) are added to the Add Transaction screen to enhance data entry flexibility.

iosApp/iosApp/screen/addTransaction/component · high confidence

The Add Transaction screen on Android now allows users to attach receipt images to transactions. This is implemented via a new UI component that integrates with the device's camera (using Android Intents) and the gallery picker, handling necessary permissions and saving the selected image to a public directory before linking it to the transaction.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/addTransaction · high confidence

The TransactionsScreen now displays all transactions loaded from the database, grouped by date with sticky headers. Users can search transactions via a text field and filter them by date, category, and type. The screen also supports swiping to delete items and includes a bottom sheet for transaction creation or editing.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/transactions · high confidence

The Android app now displays a splash screen featuring the Oakane logo and name, which fade in with animations before automatically navigating the user to the Terms and Service screen, the onboarding flow, or the home screen depending on whether they have previously accepted the terms or completed onboarding.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/splash · high confidence

The Android presentation layer now includes a dedicated view for creating new categories, allowing users to input a name, select a transaction type (Income/Expense), choose a color from a palette, and pick an icon. This component integrates with the existing state management to handle user interactions for these specific attributes before saving.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/categories/component/sheet · high confidence

Users can now set or update spending limits for specific budget categories via a new dialog. This interface includes a currency-formatted text field that respects the app's current currency settings and a searchable dropdown menu for selecting the target category, allowing users to define precise monthly limits for their expense tracking.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/monthlyBudget/component/dialog · high confidence

Users can now filter their transaction history by category, date, and type. This change introduces three new SwiftUI components—FilterByCategoryView, FilterByDateView, and FilterByTypeView—within the transactions filter section, allowing users to select specific categories, pick a date, or choose transaction types (e.g., income, expense) before applying the filter.

iosApp/iosApp/screen/transactions/component/filter · high confidence

Users can now specify which days of the week a reminder should recur. A new ReminderDay enum defines the available days (Sunday through Saturday) with localized titles, and a helper function allows conversion between string representations and these day objects, enabling the reminder model to support multi-day recurrence patterns.

core/model/src/commonMain/kotlin/com/kakapo/model/reminder · high confidence

The Transactions screen now supports filtering transactions by category, date, and type, as well as searching by text. Users can apply these filters via a bottom sheet or toggle them using chips in the top app bar, with the ability to clear individual filters directly from the UI.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/transactions/component · high confidence

A new GoalScreen has been added to display detailed information for a specific savings goal, including its associated time card, notes, and a list of individual savings logs. The screen provides actions to update or delete the goal, with deletion protected by a confirmation dialog, and supports navigation back to the previous screen.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/goal · high confidence

The iOS app now includes a new set of reusable button components in the design system, including filled, outlined, text, icon, and content-based buttons, as well as a floating action button (FabButtonView) and input chips. These components provide consistent styling and interaction patterns for user actions across the application.

iosApp/iosApp/designSystem/component/button · high confidence

Users can now configure recurring financial reminders on iOS. The new ReminderScreen allows toggling reminders on or off, selecting a specific time, and choosing which days of the week the reminder should trigger. When saved, the app schedules local notifications using the iOS UserNotifications framework to alert the user at the specified time on the selected days.

iosApp/iosApp/screen/reminder · high confidence

The Add Goal feature now includes a dedicated UI component that allows users to select an image from their device's gallery. This component handles the media selection process, saves the chosen image to a public directory, and passes the resulting file name back to the parent screen for use in the goal data.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/addGoal/component · high confidence

Users can now navigate to a new Monthly Budget screen to set and save expense limits for specific categories. The screen displays a summary view by default, switching to an edit mode where users can add category limits via a dialog. Changes are persisted using a 'Save Budget' action, and the interface includes navigation back to the previous screen.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/monthlyBudget · high confidence

The Goals screen is now accessible via a dedicated navigation route. This change introduces a new navigation file that registers the 'goals\_route' in the navigation graph, passing a boolean argument to control whether the side drawer is displayed. It also provides a helper function to navigate to this screen from other parts of the app.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/goals/navigation · high confidence

The onboarding flow now presents a screen where users can choose to create their own wallet or skip the step, in which case the system automatically creates a default wallet. This change introduces the \CreateWalletView\ UI component, which provides 'Create Wallet' and 'Skip' buttons to navigate the user through this decision point.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/onboarding/content/createWallet · high confidence

This change introduces new model classes in the presentation layer to support upcoming UI features. It defines enums for wallet sheet content states (Create, SelectIcon, SelectColor) and categories sheet content, a list of available colors for selection, an enum for onboarding steps (Account, ImportBackup, SelectCurrency, CreateWallet), and constants for the Terms and Services agreement text. These models provide the data structure needed for the corresponding screens and sheets.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/model · high confidence

Users can now create and manage reminders through a new screen that allows toggling reminders on or off, selecting specific times via a time picker dialog, and choosing repeat days. The feature includes navigation wiring and integrates with the Android AlarmManager to schedule alarms, providing a complete UI for setting up recurring alerts.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/reminder · high confidence

Android users can now delete categories by swiping list items, with the gesture triggering a delete event for the specific category. Additionally, a new modal bottom sheet allows users to create categories, select colors, and choose icons (including custom images) through dedicated selection views.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/categories/component · high confidence

The Android presentation layer now includes a dedicated TransactionScreen that displays transaction details (amount, title, wallet, category, type, date, note, and optional image) and provides edit and delete actions. Deleting a transaction now requires user confirmation via a DeleteTransactionDialogView before the deletion event is dispatched to the ViewModel.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/transaction · high confidence

The iOS app now includes a dedicated TransactionScreen that displays detailed information for a specific transaction, including its note and associated image. Users can edit or delete the transaction via toolbar actions, which trigger corresponding view model events to navigate to the edit screen or remove the item.

iosApp/iosApp/screen/transaction · high confidence

The app's design system now includes a centralized typography configuration in \TypoGraphy.swift\, defining font styles for body, display, title, headline, caption, button, overline, subtitle, and label text. This system utilizes the Poppins font family for display and headline elements and the Roboto font family for body, title, and other UI text, with corresponding license files (OFL for Poppins, Apache 2.0 for Roboto) added to the project.

iosApp/iosApp/designSystem/theme/font · high confidence

The wallet feature now includes a dedicated detail screen that displays wallet information, notes, and a history of transactions. Users can search logs by query and filter them by date and category using a bottom sheet. The screen also displays goal saving items and wallet transfer logs, with support for moving balances between wallets via a dedicated dialog.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/wallet · high confidence

The iOS wallet screen now includes a filter sheet that allows users to narrow down transaction logs by date range (including custom start/end dates) and by transaction category. This new UI component, located in the wallet sheet directory, provides the interface for selecting these filters and applying them to the log view.

iosApp/iosApp/screen/wallet/component/sheet · high confidence

Users can now filter their wallet transaction logs by time range (Last Week, Last Month, or Custom date range) and by category (Transaction, Goal Saving, or Wallet Transfer) using a new bottom sheet interface. This change introduces the Android-specific state management and Compose UI components for the filter dialog, including date pickers and reset functionality, enabling users to narrow down their wallet history view.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/wallet/component/sheet · high confidence

The application now includes a complete \Currency\ enum in the core model layer, defining over 100 currencies with their respective language codes, country codes, names, base multipliers, and display symbols (such as $, €, £, ¥, and localized symbols). This model supports lookup by country or language code and provides extension functions for converting integer ordinals to currency instances. Additionally, it introduces platform-specific \expect\ functions for formatting doubles as currency strings and numbers, enabling localized display of monetary values across different operating systems.

core/model/src/commonMain/kotlin/com/kakapo/model · high confidence

New Swift extensions have been added to the common utilities to simplify data presentation. Date objects can now be formatted into custom string patterns or converted to millisecond timestamps (Int64). Numeric types now include specific formatting helpers: Double values can be converted to Indonesian Rupiah currency strings (e.g., 'Rp100.000'), and Float values can be formatted as percentage strings with configurable decimal precision.

iosApp/iosApp/common/extensions · high confidence

The iOS design system now includes a \ViewControllerAccessor\ SwiftUI component and helper functions for file operations. Users can now save text content as files via a system share sheet using \saveDocument\, and read JSON files from URLs using \readJSONFileAsString\, enabling local data persistence and import capabilities within the app's UI layer.

iosApp/iosApp/designSystem/ui · high confidence

Users can now add savings to a goal via a new dialog that allows specifying an amount, selecting a wallet, and adding a note, and are presented with a confirmation alert before deleting a goal to prevent accidental data loss.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/goal/component/dialog · high confidence

Introduced SwiftUI views for a slide-out drawer menu in the iOS design system. The new DrawerMenuView renders a side panel that slides in from the left, displaying a list of navigation items (such as Dashboard and Categories) and allowing users to select a destination. The DrawerButtonView handles the individual item styling, highlighting the currently selected menu entry with a distinct background and text color, and triggers navigation callbacks when tapped.

iosApp/iosApp/designSystem/component/menu · high confidence

A new FileUtils.swift module has been introduced to handle image persistence on iOS. This includes capabilities to save images to the local file system, save images to the device's photo library (specifically within an 'Oakane' album), and retrieve images from the photo library using local identifiers. These utilities support the broader feature of attaching and displaying images within the transaction flow.

iosApp/iosApp/common/utils · high confidence

A new enum class \DrawerMenuNavigation\ has been introduced to define the available sections in the application's navigation drawer. This change establishes the menu structure for Dashboard, Transactions, Categories, Goals, Wallets, Reports, and Settings, providing the foundational data model for the drawer UI across the shared codebase.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/navigation · high confidence

The Android-specific navigation layer for transactions now includes a dedicated route for viewing transaction details. This change introduces a new composable screen that accepts a transaction ID as a path argument and provides callbacks to navigate to the edit screen or go back, enabling users to view and manage individual transaction records from the Android app.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/transaction/navigation · high confidence

Introduces new domain models to support wallet log filtering and transfer categorization. Users can now filter wallet logs by date (start/end) and category (Transaction, GoalSavings, Transfer, All), and wallet transfers are explicitly typed as Incoming or Outgoing with a helper to parse string representations.

core/model/src/commonMain/kotlin/com/kakapo/model/wallet · high confidence

The Android-specific dependency injection module (AndroidModule.kt) has been introduced to configure Koin bindings. This change registers singletons for the SQLDelight database driver (MySqlDriverFactory) and the Preference DataStore (OakanePreferenceDataStoreFactory), enabling these core data components to be injected into Android application components.

shared/src/androidMain · high confidence

The Android-specific UI for managing categories is now available, featuring a tabbed interface to filter by transaction type, a search bar to filter categories, and swipe-to-delete functionality for individual items. Users can also create new categories via a bottom sheet triggered by the floating action button, with navigation integrated into the app's drawer menu.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/categories · high confidence

The Android presentation layer now defines the application's navigation graph and route arguments. A new \NavArgs\ object centralizes string constants for passing data between screens (transaction, goal, wallet, drawer state, and onboarding origin). The \OakaneNavHost\ composable establishes the full navigation flow, starting from the splash screen and routing through term of service, onboarding, home, and various feature screens (transactions, goals, wallets, budgets, reports, settings, and reminders), wiring up navigation actions and back-stack handling for each.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/navigation · high confidence

The Android-specific presentation layer for the Wallets feature now includes dedicated UI components: WalletItemView renders individual wallet cards showing balance, income/expense summaries, and a selection radio button, while WalletsTopAppbarView provides the screen header with a search field and navigation controls. These components wire the local UI state to the WalletsViewModel events, enabling users to view wallet details and filter their list via search on Android.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/wallets/component · high confidence

This update introduces a suite of Android-specific UI components and background processing capabilities. Users will see new design system elements including custom buttons, checkboxes, icon buttons, toggle switches, dropdown menus, progress indicators, tabs, and various text fields (standard, search with debounce, and currency-aware with input sanitization). The navigation experience is enhanced with slide and fade screen transitions. Additionally, the app now supports generating CSV reports for financial data and scheduling daily background reminders via WorkManager.

composeApp/src · high confidence

The core model module now includes platform-specific currency formatting logic for Android. This change adds an Android manifest and a Kotlin file that implements actual functions to format double values into localized currency strings and numbers, utilizing Java's NumberFormat and DecimalFormat classes to handle locale-specific symbols and separators.

core/model/src/androidMain · high confidence

The iOS app now displays an animated splash screen featuring the Oakane logo and text, which fades in with staggered timing. Upon completion of the animation, the app automatically navigates the user to the appropriate next screen based on their previous activity: the Terms and Service screen if they have not yet accepted them, the onboarding flow if they have accepted terms but not completed onboarding, or the home screen if both are complete.

iosApp/iosApp/screen/splash · high confidence

The goal detail screen now includes dedicated UI components for displaying individual goal savings and managing goal actions. A new list item view renders saving entries with their amount, note, and date, using distinct styling for income versus expense contexts. Additionally, a centralized dialog component handles user interactions for updating goal amounts and confirming goal deletion, replacing previous inline or ad-hoc implementations with a standardized modal interface.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/goal/component · high confidence

The iOS app now includes a fully functional Goal screen, allowing users to view goal details, track savings, and manage goals through actions like updating or deleting. This feature is implemented using SwiftUI for the UI and integrates with the shared Kotlin Multiplatform logic via Koin and KMPNativeCoroutines for state management and side effects.

iosApp/iosApp/screen/goal · high confidence

The Goals screen UI has been updated to include a top app bar with a search input field. Users can now type a query to filter the list of goals in real-time, with the search state managed through the existing GoalsState and GoalsEvent architecture.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/goals/component · high confidence

The home screen now aggregates and displays key financial data, including the selected wallet balance, a list of active goals, and a monthly budget overview, in addition to recent transactions. Users can also toggle the visibility of their wallet balance via a new setting and view the current theme preference. This change introduces a shared HomeViewModel and contract that manages this state and handles navigation events to transaction, goal, budget, and wallet screens.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/home · high confidence

The iOS app now includes a foundational structure with a main content view that manages a navigation stack, a drawer menu, and dark mode support via UserDefaults. This entry establishes the core routing logic (AppNavigation) and view mapping (ContentView) for screens such as onboarding, home, transactions, goals, wallets, reports, settings, and reminders, along with the MainViewModel for initialization.

iosApp/iosApp/main · high confidence

The Android application now includes a dedicated Home screen that serves as the main dashboard. This screen displays the user's primary wallet balance, current monthly budget, a list of recent transactions, and savings goals. It provides navigation to detailed views for transactions, goals, and budgets, and includes a floating action button to quickly add new transactions.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/home · high confidence

The Goals screen is now available, displaying a scrollable list of goals that are filtered based on the current state. Users can add a new goal via the floating action button, tap an item to navigate to its details, and use the top app bar for additional actions. The screen handles navigation events and displays error toasts as needed.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/goals · high confidence

The iOS app now includes a dedicated Goals screen that allows users to view, search, and navigate to individual goals. This feature adds a new GoalsScreen SwiftUI view and a corresponding GoalsViewModel that bridges the Kotlin Multiplatform shared logic to the iOS UI. Users can filter their goals using a search bar, tap on a goal to navigate to its details, and use the floating action button to add a new goal. The screen also handles navigation events such as opening the drawer and navigating back, providing a complete interface for managing financial goals within the app.

iosApp/iosApp/screen/goals · high confidence

The iOS app now includes a new Monthly Budget screen that allows users to set and manage spending limits for specific expense categories. This change introduces the \MonthlyBudgetScreen\ and its associated \MonthlyBudgetViewModel\, which handle the UI state and business logic via Koin dependency injection. Users can view their total budget, edit the amount, and create or update category-specific limits through a dialog interface (\CreateCategoryLimitDialogView\) that supports searching and selecting categories. The implementation includes specific components for displaying category limits (\ButtonSelectCategoryLimitView\) and handling the save workflow, integrating with the shared Kotlin Multiplatform logic for data persistence.

iosApp/iosApp/screen/monthlyBudget · high confidence

The \core/domain\ module has been added to the project, establishing the business logic layer for the application. This includes new use cases for managing wallets (such as moving balances between wallets and selecting a wallet), handling goal savings (adding and saving goals), and managing transactions (saving, updating, and deleting transactions with category limit validation). The module also introduces wallet log filtering capabilities, allowing users to filter logs by query, date range, and category (transactions, goal savings, or transfers). Additionally, it provides a monthly budget overview use case and supports recurring budget settings. Platform-specific implementations for Android and iOS are included to support the cross-platform domain layer.

core/domain · high confidence

A new \core/preference\ module has been added to centralize user settings management across Android and iOS. This module implements a platform-agnostic preference data store using \androidx.datastore.preferences\, providing a unified interface for saving and retrieving user configuration such as currency selection, balance visibility toggles, recurring budget limits, and reminder schedules. The implementation includes platform-specific factories for Android and iOS to handle file path resolution, ensuring consistent preference persistence on both platforms.

core/preference · high confidence

The application now uses a dedicated \core/model\ module containing strongly-typed data classes for all core financial concepts, including Wallets, Transactions, Categories, Goals, Budgets, and Reports. This change introduces specific models such as \WalletLogItem\ to unify transaction, transfer, and goal-saving logs, \CategoryLimitModel\ for budget tracking, and \GoalSavingModel\ for saving progress. Users benefit from a more structured data foundation that supports features like wallet filtering by date, goal saving logs in the wallet view, and detailed budget overviews, ensuring consistent data handling across the app.

model · high confidence

The iOS app now uses a dedicated \WalletSheetState\ class to manage the lifecycle and data (name, balance, currency, icon, color) for wallet creation and editing, replacing previous ad-hoc state handling. A new \WalletSheetView\ acts as a container that switches between an \AddWalletSheetView\ for input and a \SelectIconSheetView\ for icon customization, providing a structured, reusable UI component for wallet management within the design system.

iosApp/iosApp/designSystem/ui/sheet/wallet · high confidence

The iOS app now includes a dedicated Wallets screen that displays a list of wallets and allows users to search for them via a text field. The screen features a floating action button to navigate to the wallet creation flow and supports navigation back or opening a drawer. State management is handled by a new ViewModel that bridges Kotlin flows to SwiftUI using Koin and native coroutines, ensuring real-time updates for wallet lists and UI effects.

iosApp/iosApp/screen/wallets · high confidence

The monthly budget feature now uses a dedicated ViewModel and contract to manage state, allowing users to set a total monthly budget, define specific spending limits for individual expense categories, and configure these budgets to recur automatically. The view model handles loading existing budgets, validating category limits, and saving both one-time and recurring budget configurations via the underlying repositories.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/monthlyBudget · high confidence

The iOS app now uses a dedicated WalletScreen and WalletViewModel to manage wallet details, history, and actions. Users can view wallet information, search and filter transaction logs, and perform actions like moving balance or deleting the wallet via dialogs. The screen integrates with the app's navigation system and displays various log items including goal savings, transactions, and transfers.

iosApp/iosApp/screen/wallet · high confidence

The iOS app now features a new HomeScreen that serves as the main dashboard, displaying the primary wallet balance, monthly budget overview, recent transactions, and goals. This screen integrates with a drawer navigation menu and includes a floating action button to quickly add new transactions. Users can tap on individual transactions or goals to view details, and the interface supports navigating to other sections like transactions, goals, and wallets through a unified effect-handling system.

iosApp/iosApp/screen/home · high confidence

The onboarding screen now uses a dedicated ViewModel that manages state for currency selection, content progression, and navigation effects. Users can now restore a backup during onboarding, which triggers navigation to the home screen, or skip wallet creation to proceed directly. The flow also supports creating a default wallet and saving the onboarding completion status, with error handling displayed via UI effects.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/onboarding · high confidence

The create wallet screen now uses a dedicated shared ViewModel (CreateWalletViewModel) and contract (CreateWalletViewContract) to manage state and logic. This change enables users to create new wallets with customizable names, notes, initial balances, currencies, colors, and icons, as well as edit existing wallets. The ViewModel handles loading saved currency settings, persisting wallet data via the repository, and managing UI interactions like sheet visibility for color and icon selection.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/createWallet · high confidence

The wallet management logic is now centralized in a common ViewModel (WalletsViewModel) backed by a new state contract (WalletsViewContract). This change enables the UI to load and display the list of wallets, filter them via a search query, and handle user interactions such as selecting a primary wallet or navigating to create a new wallet. The ViewModel also loads system-level preferences like currency and theme, ensuring the wallet list reflects the user's current settings.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/wallets · high confidence

The onboarding experience now follows a defined multi-step sequence: users set up an account, optionally restore a backup from a JSON file, select a currency, and create a wallet. This change introduces the OnBoardingScreen composable which orchestrates these steps using a state-driven approach, integrating specific content views for account setup, backup import, currency selection, and wallet creation, and handles navigation to the home screen upon completion.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/onboarding · high confidence

The build-logic convention plugins now support Kotlin Multiplatform projects, configuring Android, iOS (device, simulator, and simulator-arm64), and JVM targets with shared dependencies like Koin and kotlinx-serialization. Additionally, a new 'Oakane' build flavor dimension is introduced, allowing the app to be built as either 'demo' or 'prod' variants with distinct application IDs and names.

build-logic/convention/src/main/kotlin/com · high confidence

A new ReportsViewModel has been added to the iOS application to bridge the Kotlin Multiplatform shared logic with the iOS UI layer. This component initializes the reports data, observes state and effect flows from the shared ViewModel, and updates the local UI state on the main thread, enabling the ReportsScreen to display transaction categories and progress indicators correctly.

iosApp/iosApp/viewModel/reports · high confidence

The iOS app now includes a centralized design system for theming, providing structured access to color palettes (including primary, secondary, surface, and error colors), a comprehensive set of SF Symbols for various financial categories (such as income, expenses, and bills), standard image assets, and consistent shape styles for corner radii. This change establishes the visual foundation for the UI, allowing components to reference these constants for consistent styling across the application.

iosApp/iosApp/designSystem/theme · high confidence

This change adds new Swift model files to the iOS reports module to support local data handling and export features. It defines \ReportsState\ to manage the UI state for reports, including wallet selection, monthly overviews, and currency settings, while mapping shared Kotlin models to native Swift types. Additionally, it introduces \ReportModel\ for individual report items and \ReportCsvModel\ to structure transaction data, enabling users to generate and export their financial reports as CSV files directly from the iOS app.

iosApp/iosApp/viewModel/reports/model · high confidence

A new TransactionType enum (Income, Expense) has been added to the core model module, along with extension functions to convert between String, Long, and Int representations. This provides a standardized way to handle transaction type data within the shared model layer.

core/model/src/commonMain/kotlin/com/kakapo/model/transaction · high confidence

This change introduces new model files in the \core/model\ module that define the application's financial category structure and theme settings. Specifically, it adds \CategoryIconName\ and \ParentCategory\ enums to represent financial categories (such as Income, Housing, and Debt) along with a mapping utility, and adds a \Theme\ enum to support System, Light, and Dark modes. These definitions provide the foundational data structures for category selection and UI appearance within the shared model layer.

core/model/src/commonMain/kotlin/com/kakapo/model/category, core/model/src/commonMain/kotlin/com/kakapo/model/system · high confidence

The iOS app now includes a dedicated AddTransactionScreen that allows users to create or edit transactions with a title, amount, type, category, date, and note. This screen introduces the ability to attach images via the device camera or photo library, and for expense transactions, users can toggle an option to exclude the transaction from their budget calculations. The implementation uses a new ViewModel to manage state and handle events, integrating with the existing navigation flow.

iosApp/iosApp/screen/addTransaction · high confidence

The Android app now includes a dedicated Settings screen that allows users to change the app theme (System, Light, or Dark) via a dialog, select a currency via a bottom sheet, and manage data backups by generating or restoring JSON files. This entry covers the Android-specific UI components, navigation route, and ViewModel integration for these settings features.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/settings · high confidence

Users can now move balances between wallets via a new dialog that lets them select a destination wallet, enter an amount with currency formatting, and add an optional note. The wallet dialog component has been refactored to route between this new Move Balance view and the existing Delete Wallet confirmation, providing a consistent interface for wallet management actions.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/wallet/component/dialog · high confidence

The iOS app now includes a dedicated Reports screen that displays financial data through a donut chart, budget overview, and a list of report items. Users can filter reports by date and wallet, and can export their report data as a CSV file using the download action in the navigation bar.

iosApp/iosApp/screen/reports · high confidence

The iOS design system now includes reusable SwiftUI components for tab navigation. TabBarView renders a horizontal list of tab items, and TabBarItemView handles individual tab selection with an animated underline indicator that highlights the active tab. These components allow the app to present a standard tab-based interface with smooth spring animations for state changes.

iosApp/iosApp/designSystem/component/tab · high confidence

The iOS app introduces three new SwiftUI view modifiers to standardize UI components. \CustomBackgroundModifier\ allows views to be wrapped with configurable rounded corners, background colors, and shadows. \DynamicHeightSheetModifier\ enables sheets to automatically adjust their height based on their content using geometry preferences, replacing fixed-height presentations. \ToolbarModifier\ provides a reusable pattern for navigation bars with a back button, title, and up to two configurable action icons, simplifying the implementation of consistent header layouts across screens.

iosApp/iosApp/modifier · high confidence

The iOS app now includes a dedicated Terms and Services screen where users must review and accept four specific agreement items before proceeding. This screen, implemented in Swift using SwiftUI, displays the terms, provides checkboxes for each item, and includes a link to the project's open-source repository on GitHub. Users can only confirm their agreement via the 'I Accept and Agree' button once all required terms are checked, after which the app navigates to the onboarding flow.

iosApp/iosApp/screen/termAndService · high confidence

The iOS app now includes dedicated SwiftUI views for the monthly budget screen, allowing users to set their total monthly budget and manage per-category spending limits. The new \MonthlyBudgetTopContentView\ provides an input field for the total budget amount, while \MonthlyBudgetBottomContentView\ displays a list of category limits with progress indicators and allows users to select or add new limits in edit mode. The \CategoryLimitItemView\ renders individual category limit details, including icons, names, limits, and spent amounts.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/monthlyBudget/component, iosApp/iosApp/screen/monthlyBudget/component · high confidence

This change introduces four new Compose UI components for the Reports feature: BudgetContentView, which displays budget limits, spending progress, and income/expense breakdowns; ButtonFilterView, providing dropdown menus to filter reports by month and wallet; DonutChartComponentView, rendering an animated donut chart with a legend for expense categories; and ReportsItemView, displaying individual report items with icons, names, and formatted currency amounts.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/reports/component · high confidence

A new \WalletItemView\ SwiftUI component has been added to the wallets screen. It displays a wallet's name, icon, and color, along with formatted balance, monthly expenses, and monthly income. Users can select a wallet via a radio button or navigate to the wallet details screen by tapping the item.

iosApp/iosApp/screen/wallets/component · high confidence

The iOS app now includes a dedicated view for creating and editing categories, allowing users to input a category name, select an icon, choose between income or expense types, and pick a color. This interface supports both creation and update modes, with specific actions for saving changes or deleting an existing category.

iosApp/iosApp/screen/categories/component · high confidence

A new \TypeResult.kt\ file has been added to the \core/common\ module, introducing a \CustomResult\ sealed interface with \Success\, \Error\, and \Loading\ states. This change provides new extension functions (\asResult\, \asCustomResult\) to convert Kotlin Flows into these result streams, along with \subscribe\ and \suspendSubscribe\ helpers for observing these states, enabling a standardized way to handle asynchronous data and errors across the application.

common · high confidence

A new set of SwiftUI components (CurrencyTextFieldAdapter, CurrencyUITextField, OutlinedCurrencyTextFieldView) has been added to the design system to handle currency input. This component provides a text field that formats values as currency, supports a leading icon, displays a label, and visually indicates focus state by changing the border color. It ensures the cursor stays at the end of the input during editing and integrates with the app's color theme.

iosApp/iosApp/designSystem/component/textField/currency · high confidence

The design system now includes a custom CheckboxToggleStyle that renders a square icon with a checkmark and spring animation, and a new CategoriesView that displays a list of categories with custom row styling and tap handling.

iosApp/iosApp/designSystem/component/checkbox, iosApp/iosApp/designSystem/ui/view · high confidence

The core/data module now provides a complete data layer supporting multiple wallets, recurring monthly budgets, category limits, and goal savings. This includes repository interfaces and implementations for managing wallet balances and transfers, persisting recurring budget and category limit settings, tracking goal savings logs, and handling system preferences like theme and currency. The implementation uses a local database for transactional data and a preference datasource for user settings, enabling features such as wallet selection in transactions, balance visibility toggles, and detailed financial reporting.

core/data · high confidence

The data layer now includes mappers and repository logic to persist and restore wallet transfers, goal savings, category limits, and recurring monthly budgets. A new BackupRepositoryImpl serializes these entities (along with transactions, categories, and wallets) into a single JSON backup, allowing users to save and restore their complete financial configuration, including currency settings, across devices or reinstalls.

data · high confidence

The database layer now supports monthly budgeting, goal saving, and wallet transfers. Users can set category-specific budget limits (CategoryLimitTable) and track spending against them (MonthlyBudgetTable). A new goal saving feature allows users to create savings goals with target amounts and log contributions (GoalTable, GoalSavingTable). Wallet management has been enhanced with a dedicated transfer history (WalletTransferTable) to track movements between wallets, and transaction records now include an image attachment and an option to exclude specific transactions from budget calculations (TransactionTable).

core/database/src/commonMain/sqldelight/com · high confidence

The Add Goal screen now includes dedicated UI components for selecting dates and picking goal images. DateSelectorView allows users to choose a start date via a date picker, displaying the selected date in a formatted string and notifying the parent view of changes. GoalImagePickerView enables users to select an image from their photo library using PhotosUI, displaying the selected image in a circular view with a camera icon overlay, and handling both new selections and loading previously saved images from the local file system.

iosApp/iosApp/screen/addGoal/component · high confidence

The iOS design system now includes new text field components: OutlinedTextFieldView for standard text input with labels and placeholders, OutlinedSearchTextFieldView for search inputs with debounced query updates and clear buttons, and CurrencyTextField for numeric currency input with locale-aware formatting. These components share a consistent outlined style via OutlinedTextFieldModifier and include a DebouncedQueryObserver to handle search input delays.

iosApp/iosApp/designSystem/component/textField · high confidence

The iOS design system now includes dedicated SwiftUI views for displaying financial items: CategoryItemView renders category rows with icons and names; GoalItemView displays goal progress, amounts, and end dates; GoalSavingItemView shows saving entries with transaction-type icons and notes; TransactionIconView provides summary icons for income/expense totals; and TransactionItemView lists individual transactions with titles, categories, amounts, and dates. These components standardize how item data is presented in the app's lists and detail screens.

iosApp/iosApp/designSystem/ui/item · high confidence

Users can now move funds between wallets and delete existing wallets via dedicated confirmation dialogs. The new MoveBalanceDialogView allows selecting a destination wallet, entering an amount and optional note, and confirming the transfer. The WalletDialogView handles both the delete confirmation (warning that the action is irreversible) and the move balance flow, integrating with the wallet state to execute the respective events.

iosApp/iosApp/screen/wallet/component/dialog · high confidence

The Transactions screen now features a dedicated top app bar that includes a search field and horizontal filter chips for Type, Date, and Category. Tapping a filter chip opens a sheet to select a value, while tapping an active filter clears it. The navigation action toggles between opening the side drawer and navigating back, depending on the current context.

iosApp/iosApp/screen/transactions/component/topbar · high confidence

The design system now includes two new SwiftUI components for the top bar area: \NavigationTopAppbar\ and \TopAppbar\. \NavigationTopAppbar\ provides a flexible header with a title, a customizable action area, and a dynamic leading icon that switches between a drawer menu and a back arrow based on configuration, allowing screens to implement consistent navigation patterns. \TopAppbar\ offers a simpler, static header displaying only a title, suitable for screens that do not require navigation controls. These components replace ad-hoc implementations and provide a standardized way to render top app bars across the app.

iosApp/iosApp/designSystem/component/topbar · high confidence

The iOS goal screen now uses dedicated SwiftUI views to display goal details. CardGoalView renders the goal icon, name, and a progress bar, alongside current and target amounts. CardTimeView displays the start and end dates and the number of days remaining. These components rely on the new CardContentWithIconView helper to consistently format icon-title-content pairs.

iosApp/iosApp/screen/goal/component/card · high confidence

The goal screen now uses dedicated Compose components to display goal details. CardGoalView renders the goal's progress, showing the current saved amount versus the target amount alongside a goal icon. CardTimeView displays the start and end dates of the goal along with the number of days remaining. These components rely on a shared CardContentWithIconView helper to present labeled data pairs with icons.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/goal/component/card · high confidence

The iOS goal screen now includes dedicated UI components for adding and deleting goals. A new dialog allows users to specify a savings amount via a currency text field, while a separate confirmation dialog handles goal deletion with a warning that the action cannot be undone.

iosApp/iosApp/screen/goal/component · high confidence

The home screen now displays a primary wallet view with a toggleable balance visibility, a monthly budget section showing the spending limit, progress, and remaining amount, and a breakdown of total income and expenses. A 'Show More' button is also added to the home view to expand additional content. These changes enhance the home screen's ability to provide a comprehensive overview of the user's financial status.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/home/component · high confidence

The home screen now includes dedicated UI components for displaying the primary wallet balance (with a toggle to mask/unmask the amount), monthly budget progress (including income and expense breakdowns), and goal management headers. These additions introduce new visual elements for financial overview and interaction on the home screen.

iosApp/iosApp/screen/home/component · high confidence

The iOS app now includes a dedicated Categories screen that allows users to browse, search, and manage categories. The interface features a tabbed view separating income and expense categories, a search field to filter results, and a floating action button to create new categories. Users can customize new categories by selecting icons and colors via a bottom sheet, and the screen supports navigation back and drawer toggling.

iosApp/iosApp/screen/categories · high confidence

The iOS app now includes a dedicated Settings screen that allows users to manage their preferences and data. Users can set their preferred currency via a selection sheet, toggle dark appearance mode, and enable recurring monthly budget or category limits. The screen also provides options to generate a backup file for export and import previously saved data. Additionally, a new button navigates users to the Reminder feature, handling notification permission requests automatically.

iosApp/iosApp/screen/settings · high confidence

Users can now create new wallets directly on iOS via a dedicated screen that allows setting a wallet name, choosing a custom icon (from a selector or by uploading an image), selecting a display color, entering an initial balance, and adding a note. The screen handles navigation back to the previous view or to the home screen upon successful creation, integrating with the existing app navigation and shared state management.

iosApp/iosApp/screen/createWallet · high confidence

The design system now includes four new icon components in the \iosApp/designSystem/component/icon\ directory: \CategoryIconView\ for rendering system icons with adaptive foreground colors, \SelectedIconView\ for displaying either system icons or custom image files with optional circular strokes, \TransactionTypeIconView\ for visualizing income and expense transactions with specific color themes, and \GithubIcon\ as a custom SVG-like shape. These components provide reusable UI elements for consistent iconography across the app.

iosApp/iosApp/designSystem/component/icon · high confidence

Added two new SwiftUI views in the design system's image component directory: DisplayImageFileView, which renders a circular image from a local file identifier with a fallback default icon, and TransactionImagePreView, which displays an image from a local identifier within a rounded container and includes an optional dismiss button. Both components handle asynchronous image loading and react to changes in their input identifiers.

iosApp/iosApp/designSystem/component/image · high confidence

The onboarding flow now includes dedicated UI screens for creating an offline account and importing existing backups. Users can choose to start with an offline account, which stores data locally on the device, or import a backup from a previous device or export. The import screen offers options to restore from a backup or start fresh, guiding users through initial data setup.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/onboarding/content · high confidence

Users can now configure reminder settings through a new screen that allows them to enable or disable reminders, select a specific time (hour and minute), and choose which days of the week the reminder should trigger. The feature persists these preferences via the settings repository and provides feedback on success or errors during saving.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/reminder · high confidence

The reports screen now includes dedicated UI components that enhance how users interact with financial data. Users can filter reports by month and specific wallet using the new ButtonFilterReportView. A DonutChartComponentView visualizes spending proportions with a central balance display and a legend, while ReportBudgetContentView tracks budget progress with income and expense summaries. Additionally, ReportItemView provides a standardized list item for displaying individual report entries with icons, names, and formatted currency amounts.

iosApp/iosApp/screen/reports/component · high confidence

The iOS app now includes two new SwiftUI components in the design system: \DeleteContentDialogView\, which provides a standardized confirmation dialog with title, subtitle, and cancel/delete actions, and \PopUpDialog\, a generic wrapper that displays custom content in a centered modal with an optional dismissable overlay. These components standardize how dialogs are presented and dismissed across the application, improving consistency in the user interface for actions like deletion or category creation.

iosApp/iosApp/designSystem/component/dialog · high confidence

The app now includes a unified settings screen (shared across Android and iOS) that lets users manage their preferences. Users can change the app theme (including dark mode), select a currency, and toggle recurring monthly budgets and category limits. The screen also supports creating and restoring data backups via JSON files, and provides navigation to a new reminder feature.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/settings · high confidence

This change introduces a set of new reusable SwiftUI components within the design system to support upcoming feature implementations. Specifically, it adds a date picker with custom scaling, a horizontal color selector with a custom color picker integration, a progress indicator with animated transitions, an outlined circle icon component, a horizontal divider, a selection picker for transaction types, and a comprehensive icon selection view that allows users to choose from system icons or upload images from their photo library. These components provide the foundational UI elements needed for category management, wallet creation, and transaction entry screens.

iosApp/iosApp/designSystem/component/supporting · high confidence

Added three new SwiftUI components for the transaction detail screen: TransactionTopContentView displays the transaction amount and title with color coding for income versus expense; TransactionDetailContentView presents structured details including wallet, category, type, and date; and TransactionNoteView renders the transaction note. These components provide the visual structure for viewing transaction information.

iosApp/iosApp/screen/transaction/component · high confidence

The iOS wallet screen now includes dedicated SwiftUI components for displaying wallet details and individual transfer history items. Users will see a new WalletDetailItemView that presents the wallet name, color-coded icon, formatted balance, and a summary of income versus expenses. Additionally, a new TransferLogItemView renders individual transactions with distinct visual styling for incoming versus outgoing transfers, including specific icons, color themes, and formatted currency amounts.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/wallet/component, iosApp/iosApp/screen/wallet/component · high confidence

The new SplashViewModel loads the user's onboarding and terms-of-service acceptance status from the SettingsRepository upon initialization. This allows the application to determine whether to show the onboarding flow or the terms screen, ensuring users are only prompted for these actions if they have not previously completed them.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/splash · high confidence

Users can now import recurring budget settings into the current month. The new ImportRecurringBudgetUseCase checks if a monthly budget already exists; if not, it retrieves the saved recurring budget and category limits from the backup and applies them as the active monthly budget and associated category limits.

domain · high confidence

The iOS onboarding flow now includes dedicated SwiftUI views for each step: AccountContentView presents the initial offline account option with local storage warnings; CreateWalletContentView allows users to create a new wallet or skip to a default; ImportBackupContentView enables restoring data from a JSON backup file or starting fresh; and SelectCurrencyContentView provides a searchable list to set the primary currency. These components define the user interface for the initial setup stages on iOS.

iosApp/iosApp/screen/onBoarding/component · high confidence

The iOS application now includes a dedicated view model for the settings screen, bridging the Kotlin Multiplatform shared logic to the native iOS UI layer. This component manages the settings state and effects using Combine publishers, allowing the interface to react to user interactions and data updates from the shared core.

iosApp/iosApp/viewModel/settings · high confidence

This change introduces platform-specific Kotlin files for the iOS target to support Swift interop and native formatting. It adds \Currency.iOS.kt\ to handle currency and number formatting using native iOS \NSNumberFormatter\ APIs, ensuring correct locale-aware display. It also provides extension functions for \GoalModel\ and \TransactionModel\ lists (\swiftTake\) to facilitate list slicing from Swift code, and adds utility functions in \CategoryModel.kt\ and \CategoryIconName.kt\ to filter categories by transaction type and retrieve subcategory names, supporting the iOS UI layer's data access patterns.

core/model/src/iosMain · high confidence

The legacy Greeting class, which previously returned a platform-specific greeting string, has been removed from the shared codebase. This cleanup eliminates unused boilerplate code from the common module.

shared/src/commonMain/kotlin/com/kakapo/oakane · high confidence

The application now uses Koin for dependency injection, consolidating the wiring of local data sources, repositories, domain use cases, and ViewModels into a shared \CommonModule\. This change establishes a unified initialization flow (\initKoin\) that binds platform-specific modules with shared business logic, ensuring consistent object creation across Android and iOS clients.

shared/src/commonMain/kotlin/com/kakapo/oakane/di · high confidence

The database implementation has been moved to a new \core/database\ module, introducing a clean separation between data-source interfaces (in \datasource/base\) and their SQLDelight-backed implementations (in \datasource/impl\). This refactor standardizes all data access across Wallets, Transactions, Categories, Budgets, Goals, and Transfers by wrapping results in \Result\<T\>\ and exposing data via Kotlin Flows. A key user-facing capability added here is comprehensive backup and restore support: every entity now includes \get...ForBackup\ and \restore...\ methods, ensuring that wallet balances, transaction history, category limits, and goal savings can be persisted and recovered reliably.

core/database/src/commonMain/kotlin · high confidence

The iOS application now uses Koin for dependency injection, replacing previous manual wiring. This change introduces platform-specific modules that provide the SQLDelight database driver and the Oakane preference DataStore, enabling shared Kotlin code to access these core services on iOS through the new KoinIos initializer.

shared/src/iosMain/kotlin/com/kakapo/oakane/di · high confidence

The TransactionsView component now supports deleting transactions via swipe gestures and navigating to transaction details by tapping an item. This adds interactive capabilities to the existing list display, allowing users to manage their transaction history directly from the screen.

iosApp/iosApp/screen/transactions/component · high confidence

Users can now navigate to the Add Transaction screen from other parts of the app, passing a specific transaction ID for editing or creation. This navigation entry includes a custom slide animation for entering the screen and provides a mechanism to navigate back to the previous screen upon completion.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/addTransaction/navigation · high confidence

The Add Transaction feature has been enhanced to allow users to select a specific wallet for each transaction and to optionally exclude transactions from budget calculations. The view model now manages wallet lists and selection state, and the transaction model includes an 'excludeFromBudget' flag that is persisted and loaded during edit operations.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/addTransaction · high confidence

A new workspace configuration file (contents.xcworkspacedata) has been added to the iOS project structure. This file initializes the Xcode workspace container, which is a prerequisite for managing multiple targets or integrating Swift Package Manager dependencies within the iOS application.

iosApp/iosApp.xcodeproj · medium confidence

The Android-specific database driver factory now explicitly handles schema migration from version 3 to 4 during driver creation, ensuring the local SQLite database structure is updated before adding default categories.

core/database/src/androidMain/kotlin · high confidence

The Android module now provides platform-specific implementations for shared utilities, including date formatting and day-difference calculations using Java's SimpleDateFormat, currency formatting for IDR via NumberFormat, and file management functions to save and retrieve images from public directories or MediaStore. It also includes a basic AndroidManifest.xml, a platform identifier function, and a Toast utility for displaying messages.

core/common/src/androidMain · high confidence

The Categories screen now uses a Model-View-Intent (MVI) pattern, replacing previous lambda-based event handling with a structured contract. This introduces a centralized \CategoriesState\ data class to manage UI state (including search, tabs, sheet visibility, and category details) and a \CategoriesViewModel\ that processes specific \CategoriesEvent\ actions (such as search, tab changes, saving, updating, and deleting categories) to produce \CategoriesEffect\ outcomes. This change ensures consistent state handling and clearer separation of concerns for category management operations.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/categories · high confidence

The composeApp module now ignores generated release artifacts (such as .aab, .apk, and baseline profile files) and the google-services.json file in .gitignore to prevent cluttering the repository with build outputs. Additionally, a new proguard-rules.pro file has been added to ensure that kotlinx.serialization classes, annotations, and serializable fields are preserved during code shrinking and obfuscation.

composeApp · high confidence

The goal screen's view model has been restructured to manage a richer state, including the ability to add and track individual savings against a goal. Users can now input a saving amount, select a specific wallet for the transaction, and add notes, with these actions handled via new events like AddSaving and ChangeWallet. The view model now loads and displays a list of goal savings (renamed from GoalTransaction to GoalSavings) and updates the goal's total saved money in real-time. Additionally, it handles goal deletion with a confirmation dialog and ensures the UI reflects the user's selected currency and theme.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/goal · high confidence

The goal feature now supports navigation to a specific goal screen by passing a goal ID. This allows the application to load and display data for an existing goal when navigating from other parts of the app, such as the home or wallet screens, enabling users to view and update specific goal details.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/goal/navigation · high confidence

The Goals screen now allows users to filter their list of goals by name using a search query, updating the displayed list in real-time. This change introduces a new MVVM architecture for the Goals feature, replacing previous lambda-based implementations with a dedicated ViewModel that manages state and effects. Additionally, the ViewModel integrates with KMP-nativecoroutines to ensure proper coroutine handling on iOS, improving stability and interoperability for the native platform.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/goals · high confidence

The iOS app now initializes the Koin dependency injection framework at launch via the new Koin.swift singleton, replacing the previous placeholder ContentView with a structure that injects an AppNavigation environment object. Additionally, Info.plist has been updated to include required privacy descriptions for photo library and camera access, enabling features that interact with device hardware.

iosApp/iosApp · high confidence

The iOS app now features a dedicated Transactions screen that displays a list of transactions and supports filtering by type, date, and category via a bottom sheet. This implementation replaces the previous navigation and state management approach with an MVVM pattern using KMP-native coroutines to bridge Kotlin flows to SwiftUI, ensuring reactive updates for UI state and effects like navigation and error handling.

iosApp/iosApp/screen/transactions · high confidence

The wallet presentation layer now uses a centralized WalletViewModel and WalletViewContract to manage wallet state, enabling users to move balances between wallets, filter transaction logs by query, date, and category, and delete wallets. This change consolidates wallet editing, balance transfer, and log filtering logic into a single view model, improving state consistency and event handling for these core wallet features.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/wallet · high confidence

The home screen now uses a dedicated navigation route ("home") and exposes callbacks to navigate to related features, including transactions (list and detail), goals (list and detail), monthly budget, and wallets.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/home/navigation · high confidence

The main view model now loads the user's saved theme preference and triggers the import of recurring budgets when the app starts. Users will see their preferred theme applied immediately, and any recurring budget data will be imported in the background without blocking the initial UI load.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/main · high confidence

This change introduces three new build-logic convention plugins to standardize project configuration. The AndroidApplicationFlavorsConventionPlugin applies flavor configurations to Android applications. The KotlinMultiPlatformPlugin sets up Kotlin Multiplatform projects by applying necessary plugins (Kotlin Multiplatform, Android Library, Serialization), configuring Android and KMP extensions, and removing specific Android test source sets to reduce log noise. The XCFrameworkPlugin automates the assembly and copying of XCFrameworks for iOS, handling intermediate cleanup and validating that the Kotlin Multiplatform plugin and iOS directory are present.

build-logic/convention/src/main/kotlin · high confidence

The iOS onboarding experience has been rebuilt using a dedicated SwiftUI view and ViewModel. Users now progress through a structured sequence of screens—account setup, backup import, currency selection, and wallet creation—driven by a centralized state machine. The implementation switches the underlying reactive flow from Skie to kmp-coroutine native, ensuring smoother navigation transitions and consistent state updates across the onboarding journey.

iosApp/iosApp/screen/onBoarding · high confidence

This change introduces a new set of utility functions in the common module to support core application features. DateUtils provides helpers for Unix time conversion, date formatting, and calculating month boundaries, which enables the new date picker and filtering capabilities in the wallet log. StringExt adds robust parsing for currency values (handling comma/period separators) and color strings, fixing previous errors when saving starting balances or converting color formats. TypeExt includes a helper to format currency values (specifically IDR), supporting the display of currency symbols in the wallet creation flow.

core/common/src/commonMain · high confidence

The database layer now includes new entity definitions and serialization logic to support wallet transfers, goal savings, and budget exclusions. Specifically, this change introduces \WalletTransferEntity\ to store and retrieve transfer history between wallets, \GoalSavingsEntity\ (renamed from \GoalTransaction\) to track savings contributions toward goals, and \CategoryLimitEntity\ to manage per-category budget limits. Additionally, \TransactionEntity\ has been updated to support an \excludedBudget\ flag for budget exclusions and an \imageFile\ field for transaction images, while \WalletEntity\ now tracks income and expense totals.

database · high confidence

The onboarding flow is now integrated into the app's navigation graph, allowing users to transition from the onboarding screen directly to the home screen or to the wallet creation process. This change establishes the navigation route and handlers required to connect these key user journeys.

composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/onboarding/navigation · high confidence

The Reports screen has been updated to allow users to filter transaction data by a specific month and by individual wallets. The new ReportsViewModel manages state for selected wallets and months, loading transaction categories and budget overviews based on these filters. Users can now view reports for a single wallet or all wallets, and the UI reflects the selected month and wallet context, improving the granularity of financial insights.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/reports · high confidence

The category icon mapping logic has been refactored to use a dedicated \CategoryIconMapper\ extension on \CategoryIconName\. This change replaces previous string-constant-based lookups with a structured enum-to-SwiftUI-icon mapping, ensuring that every financial category (such as salary, groceries, or utilities) consistently resolves to a specific icon asset. This improves type safety and maintainability for how category icons are displayed in the app's design system.

iosApp/iosApp/designSystem/model · high confidence

The application now supports recurring budget reminders. This change introduces a new database migration (migration 4) and adds a \ReminderPrefs\ data class to the preference model, which stores reminder settings including enabled status, selected hour and minute, and a list of reminder identifiers.

core/database/src/commonMain/sqldelight/migrations, preference · medium confidence

The transaction screen's presentation layer has been refactored to use a shared \TransactionViewModel\ that exposes state and effects via \kmp-nativecoroutines\, enabling seamless integration with both Android and iOS UIs. This change introduces a structured contract (\TransactionViewContract\) defining the transaction state, events (such as delete, edit, and navigation), and effects, ensuring consistent behavior across platforms while supporting features like wallet info display and currency formatting based on user settings.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/transaction · high confidence

The shared TransactionsViewModel has been refactored to use an MVI pattern with KMP-nativecoroutines, enabling users to search transactions by title, filter by type, date, and category, and delete items directly from the list. The view model now loads all transactions from the database and applies these filters in real-time, exposing the filtered list to the UI while handling effects like navigation and error display.

shared/src/commonMain/kotlin/com/kakapo/oakane/presentation/viewModel/transactions · high confidence

The iOS-specific database driver implementation has been updated to automatically add default categories upon creation. This change ensures that the local database is pre-populated with standard category data when the application starts on iOS, rather than requiring manual setup or relying on external initialization steps.

core/database/src/iosMain · high confidence

The iOS platform detection logic in the shared module has been updated to format the system name and version string with a space separator, ensuring consistent identification of the iOS environment across the application.

shared/src/iosMain/kotlin/com/kakapo/oakane · high confidence

The iOS application project has been renamed from 'iosApp' to 'oakane', updating the target name, product reference, and workspace structure. The build configuration now includes several new framework dependencies: KMPNativeCoroutines (Async, Combine, Core, RxSwift) and SVGKit (including Swift variant), which are added as both linked frameworks and Swift package references. The project structure has been reorganized to use file-system synchronized groups for modules like designSystem, screen, modifier, viewModel, common, and main. Additionally, the Xcode project version has been upgraded to objectVersion 70 (LastUpgradeCheck 1610), and the development team ID has been explicitly set to RF2V894835. A new Koin.swift file has been added to the sources, and the previous ContentView.swift has been removed from the build.

iosApp/oakane.xcodeproj · high confidence

The Gradle wrapper has been upgraded from version 8.7 to 8.11.1. This change ensures that the project uses the newer Gradle distribution for builds, which may include performance improvements, bug fixes, and new features available in the 8.11.x release line.

gradle · high confidence

The project has been restructured into a multi-module architecture, introducing new core modules for common utilities, data, database (SQLDelight), domain logic, model definitions, and preferences, alongside a new \build-logic\ convention plugin to manage shared build configurations. This refactoring is accompanied by a significant upgrade of the Kotlin compiler from version 2.0.20 to 2.1.10 and the Android Gradle Plugin from 8.2.2 to 8.9.0, which raises the minimum Android SDK requirement from 24 to 26 and the target SDK to 35. The shared module now exports these new core modules via an XCFramework for iOS consumption, and the Android application module has been updated to use Material 3, Firebase Crashlytics, and camera dependencies.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 53 → 54 (+0.7)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 100 (-0.2)
• Architecture 99 → 95 (-3.9)
• Maturity 58 → 59 (+0.4)
• Readiness 24 → 25 (+0.3)
• Security 92 → 100 (+7.5)
• Domain Modelling 100 → 100 (+0.0)

• Boundary-crossing change coupling: CreateCategoryContentView.kt ↔ CategoriesViewModel.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/categories/component/sheet/CreateCategoryContentView.kt)
• Change coupling: CategoriesSheetView.kt ↔ CreateCategoryContentView.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/categories/component/CategoriesSheetView.kt)
• Change coupling: TransactionsScreen.kt ↔ TransactionsTopAppBarView.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/transactions/TransactionsScreen.kt)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• Duplicated block (10 lines × 2) (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/addTransaction/component/SelectCategorySheet.kt)
• Duplicated block (10 lines × 2) (core/common/src/androidMain/kotlin/com/kakapo/common/FileUtils.kt)
• Duplicated block (11 lines × 2) (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/reports/component/ButtonFilterView.kt)
• Duplicated block (17 lines × 2) (core/database/src/commonMain/kotlin/com/kakapo/database/model/TransactionEntity.kt)
• Medium: security finding (details withheld)
• No exposed public API
• Rotate the exposed credentials — git history can't be un-committed
• Test reliability not included
• single-maintainer — knowledge-concentration (bus factor) risk

• Boundary-crossing change coupling: CategoriesSheetView.kt ↔ CategoriesViewModel.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/categories/component/CategoriesSheetView.kt)
• Boundary-crossing change coupling: CategoryItemView.kt ↔ CategoriesViewContract.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/ui/component/item/category/CategoryItemView.kt)
• Boundary-crossing change coupling: CategoryItemView.kt ↔ CategoriesViewModel.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/ui/component/item/category/CategoryItemView.kt)
• Boundary-crossing change coupling: GoalItemView.kt ↔ CommonModule.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/ui/component/item/GoalItemView.kt)
• Boundary-crossing change coupling: MonthlyBudgetView.kt ↔ HomeViewModel.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/home/component/MonthlyBudgetView.kt)
• Boundary-crossing change coupling: PrimaryWalletView.kt ↔ HomeViewModel.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/home/component/PrimaryWalletView.kt)
• Boundary-crossing change coupling: SelectIconVIew.kt ↔ CategoriesViewContract.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/ui/component/sheet/SelectIconVIew.kt)
• Boundary-crossing change coupling: TransactionsTopAppBarView.kt ↔ TransactionsViewModel.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/transactions/component/TransactionsTopAppBarView.kt)
• Change coupling: CategoryLocalDatasourceImpl.kt ↔ CategoriesViewModel.kt (core/database/src/commonMain/kotlin/com/kakapo/database/datasource/impl/CategoryLocalDatasourceImpl.kt)
• Change coupling: CreateCategoryContentView.kt ↔ SelectIconVIew.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/presentation/feature/categories/component/sheet/CreateCategoryContentView.kt)
• Change coupling: CreateWalletSheetView.swift ↔ WalletsScreen.swift (iosApp/iosApp/designSystem/ui/sheet/CreateWalletSheetView.swift)
• Change coupling: MainActivity.kt ↔ OakaneNavigation.kt (composeApp/src/androidMain/kotlin/com/kakapo/oakane/MainActivity.kt)
• Change coupling: MonthlyBudgetRepositoryImpl.kt ↔ MonthlyBudgetViewModel.kt (core/data/src/commonMain/kotlin/com/kakapo/data/repository/impl/MonthlyBudgetRepositoryImpl.kt)
• Change coupling: MySqlDriverFactory.kt ↔ CommonModule.kt (core/database/src/androidMain/kotlin/com/kakapo/database/MySqlDriverFactory.kt)
• Change coupling: TransactionRepository.kt ↔ TransactionLocalDatasource.kt (core/data/src/commonMain/kotlin/com/kakapo/data/repository/base/TransactionRepository.kt)
• Change coupling: TransactionRepository.kt ↔ TransactionLocalDatasourceImpl.kt (core/data/src/commonMain/kotlin/com/kakapo/data/repository/base/TransactionRepository.kt)
• Change coupling: TransactionRepositoryImpl.kt ↔ TransactionLocalDatasourceImpl.kt (core/data/src/commonMain/kotlin/com/kakapo/data/repository/impl/TransactionRepositoryImpl.kt)
• Change coupling: WalletMapper.kt ↔ WalletRepositoryImpl.kt (core/data/src/commonMain/kotlin/com/kakapo/data/model/WalletMapper.kt)
• Change coupling: WalletRepository.kt ↔ WalletLocalDatasourceImpl.kt (core/data/src/commonMain/kotlin/com/kakapo/data/repository/base/WalletRepository.kt)
• Change coupling: WalletRepositoryImpl.kt ↔ WalletLocalDatasourceImpl.kt (core/data/src/commonMain/kotlin/com/kakapo/data/repository/impl/WalletRepositoryImpl.kt)
• …and 20 more

• Containers 0 added · 0 removed · contexts 7 added · 0 removed · edges 11 added · 0 removed

• common
• composeApp
• data
• database
• domain
• model
• preference

• composeApp → data
• composeApp → model (coupling)
• composeApp → shared
• data → database (coupling)
• data → model (coupling)
• data → preference (coupling)
• domain → data (coupling)
• domain → model (coupling)
• shared → data (coupling)
• shared → domain
• shared → model (coupling)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Uwi0/Oakane was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.