Architecture Overview

src/
├── lib/
│   ├── Components/          # Reusable Svelte components
│   │   ├── Button.svelte
│   │   ├── Card.svelte
│   │   ├── Dialog.svelte
│   │   ├── Switch.svelte
│   │   └── TrackerList.svelte
│   ├── db/                  # Database layer
│   │   ├── schema.ts        # Drizzle schema definitions
│   │   └── database.ts      # Database connection
│   ├── stores/              # Svelte stores
│   │   └── deleteStore.ts
│   ├── appdata.ts           # Database operations
│   ├── trackerService.ts    # Tracker business logic
│   └── settingsService.ts   # Settings management
├── routes/                  # SvelteKit routes
│   ├── +page.svelte         # Main tracker view
│   ├── completed/           # Completed tasks view
│   └── daily/               # Daily tasks view
└── app.d.ts                 # TypeScript declarations

src-tauri/
├── src/
│   ├── services/            # Core backend services
│   │   ├── tray_service.rs         # System tray integration
│   │   ├── notification_service.rs # Hourly reminders
│   │   ├── autostart_service.rs    # System startup integration
│   │   ├── refresh_dailies_service.rs # Daily task reset
│   │   └── settings_service.rs     # User preferences
│   ├── lib.rs               # Application entry point
│   ├── main.rs              # Binary entry point
│   └── migration_manager.rs # Database migrations
├── Cargo.toml               # Rust dependencies
└── tauri.conf.json          # Tauri configuration

pub async fn init(app: AppHandle) {
    let _ = TrayIconBuilder::new()
        .tooltip("Minimal Tracker App")
        .icon(app.default_window_icon().unwrap().clone())
        .menu(&menu)
        .show_menu_on_left_click(false)
        .on_tray_icon_event(|tray, event| {
            // Handle tray clicks
        })
        .build(&app);
}

pub async fn init(app: AppHandle) {
    tokio::spawn(async move {
        loop {
            let now = chrono::Local::now();
            let next_hour = (now + chrono::Duration::hours(1))
                .with_minute(0).unwrap()
                .with_second(0).unwrap();
            
            let dur: Duration = (next_hour - now).to_std().unwrap();
            sleep(dur).await;
            
            // Check if reminders are enabled
            if enabled == false { continue; }
            
            app.notification()
                .builder()
                .title("Reminder")
                .body("Did you finish all of your tasks today?")
                .show()
                .unwrap();
        }
    });
}

export const trackers = sqliteTable("trackers", {
    id: integer().primaryKey(),
    name: text().notNull(),
    amount: integer().notNull(),
    progress: integer().notNull(),
    completed: integer({ mode: "boolean" }).notNull(),
    isDaily: integer("is_daily", { mode: "boolean" }).notNull(),
    lastModifiedAt: integer("last_modified_at", {
        mode: "timestamp",
    })
        .notNull()
        .$defaultFn(() => new Date())
        .$onUpdateFn(() => new Date()),
});

export const TrackerService = {
    async refresh(): Promise<void> {
        trackers.set(await dbGetAllTrackers());
    },
    
    async add(name: string, amount?: number, daily?: boolean): Promise<void> {
        const tracker: InsertTracker = {
            id: undefined,
            name,
            amount: amount ?? 1,
            progress: 0,
            completed: false,
            isDaily: daily ?? false,
        };
        const new_tracker = await dbAddTracker(tracker);
        trackers.update((current) => {
            current.push(new_tracker);
            return current;
        });
    },
    
    async increment(tracker: SelectTracker): Promise<void> {
        const newProgress = Math.min(tracker.progress + 1, tracker.amount);
        // Update store and database
    },
    
    // ... more operations
};

import { invoke } from '@tauri-apps/api/core';

const settings = await invoke('get_settings');
await invoke('set_autostart', { enabled: true });

app.listen_any("settings_changed", move |_event| {
    // React to settings changes
});

pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_positioner::init())
        .plugin(tauri_plugin_store::Builder::new().build())
        .plugin(tauri_plugin_autostart::Builder::new().build())
        .plugin(tauri_plugin_notification::init())
        .plugin(tauri_plugin_sql::Builder::new()
            .add_migrations("sqlite:appdb.sqlite", migration_manager::get_migrations())
            .build())
        .setup(|app| {
            // Start System Tray
            tauri::async_runtime::spawn(tray_service::init(handle.clone()));
            
            // Start User Settings Service
            settings_service::init(handle.clone(), handle.state());
            
            // Start the hourly Notification Service
            tauri::async_runtime::spawn(notification_service::init(handle.clone()));
            
            // Start Daily Task service
            tauri::async_runtime::spawn(refresh_dailies_service::init(handle.clone()));
            
            // Start Autostart Service
            autostart_service::init(handle.clone());
            
            Ok(())
        })
        // Prevent exit on window close
        .run(|_app_handle, event| match event {
            tauri::RunEvent::ExitRequested { api, code, .. } => {
                if code.is_none() {
                    api.prevent_exit();
                }
            }
            _ => {}
        });
}