Adding Features Workflow

git checkout develop
git pull origin develop
git checkout -b feature/my-feature-name

// src-tauri/src/utils/feature.rs

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct FeatureData {
    pub id: i32,
    pub name: String,
    pub value: String,
}

#[tauri::command]
pub async fn get_feature_data() -> Result<Vec<FeatureData>, String> {
    // Implementation
    Ok(vec![])
}

#[tauri::command]
pub async fn save_feature_data(data: FeatureData) -> Result<(), String> {
    // Implementation
    Ok(())
}

// src-tauri/src/lib.rs
mod utils;
use utils::feature::*;

.invoke_handler(tauri::generate_handler![
    get_feature_data,
    save_feature_data,
])

<!-- src/routes/new-feature/+page.svelte -->
<script lang="ts">
  import { onMount } from 'svelte';
  import { invoke } from '@tauri-apps/api/core';
  import { useDataLoader } from '$lib/utils/useDataLoader';
  
  let items = $state<FeatureData[]>([]);
  let loading = $state(true);
  
  onMount(async () => {
    const data = await useDataLoader({
      cacheKey: 'feature_data',
      ttlMinutes: 10,
      context: 'feature',
      functionName: 'loadFeatureData',
      fetcher: async () => {
        return await invoke<FeatureData[]>('get_feature_data');
      },
      onDataLoaded: (data) => {
        items = data;
        loading = false;
      }
    });
  });
</script>

{#if loading}
  <LoadingSpinner />
{:else}
  {#each items as item (item.id)}
    <FeatureCard {item} />
  {/each}
{/if}

// src/lib/services/featureService.ts
import { invoke } from '@tauri-apps/api/core';

export interface FeatureData {
  id: number;
  name: string;
  value: string;
}

export const featureService = {
  async load(): Promise<FeatureData[]> {
    return await invoke<FeatureData[]>('get_feature_data');
  },
  
  async save(data: FeatureData): Promise<void> {
    await invoke('save_feature_data', { data });
  }
};

<!-- src/lib/components/FeatureCard.svelte -->
<script lang="ts">
  interface Props {
    item: FeatureData;
  }
  
  let { item }: Props = $props();
</script>

<div class="feature-card">
  <h3>{item.name}</h3>
  <p>{item.value}</p>
</div>

// featureService.test.ts
import { describe, it, expect } from 'vitest';
import { featureService } from './featureService';

describe('featureService', () => {
  it('loads feature data', async () => {
    const data = await featureService.load();
    expect(Array.isArray(data)).toBe(true);
  });
});

## New Feature

Description of how to use the feature...

## Feature Implementation

How the feature works internally...

## Description
Brief description of the feature

## Changes
- Added new route `/new-feature`
- Created `FeatureCard` component
- Added `get_feature_data` Tauri command

## Testing
- [ ] Tested on Windows
- [ ] Tested on macOS
- [ ] Tested on Linux
- [ ] Manual testing completed

## Screenshots
(if applicable)

// src-tauri/src/utils/notes.rs

#[tauri::command]
pub fn save_note(note_id: String, content: String) -> Result<(), String> {
    let notes_dir = get_notes_directory()?;
    let file_path = notes_dir.join(format!("{}.md", note_id));
    fs::write(&file_path, content)
        .map_err(|e| format!("Failed to save note: {}", e))
}

#[tauri::command]
pub fn load_note(note_id: String) -> Result<String, String> {
    let notes_dir = get_notes_directory()?;
    let file_path = notes_dir.join(format!("{}.md", note_id));
    fs::read_to_string(&file_path)
        .map_err(|e| format!("Failed to load note: {}", e))
}

// src/lib/services/notesService.ts
export class NotesService {
  async saveNote(id: string, content: string): Promise<void> {
    await invoke('save_note', { note_id: id, content });
  }
  
  async loadNote(id: string): Promise<string | null> {
    try {
      return await invoke<string>('load_note', { note_id: id });
    } catch {
      return null;
    }
  }
}

export const notesService = new NotesService();

<!-- src/routes/notes/+page.svelte -->
<script lang="ts">
  import { notesService } from '$lib/services/notesService';
  import { onMount } from 'svelte';
  
  let content = $state('');
  let noteId = $state('note-1');
  
  onMount(async () => {
    const loaded = await notesService.loadNote(noteId);
    if (loaded) {
      content = loaded;
    }
  });
  
  async function save() {
    await notesService.saveNote(noteId, content);
  }
</script>

<textarea bind:value={content} />
<button onclick={save}>Save</button>

// ✅ Good - Minimal viable feature
async function loadData() {
  return await invoke('get_data');
}

// ❌ Avoid - Over-engineered
async function loadDataWithRetryAndCacheAndValidation() {
  // Too complex for first version
}

// ✅ Good - Use existing patterns
const data = await useDataLoader({
  cacheKey: 'data',
  fetcher: async () => await invoke('get_data')
});

// ❌ Avoid - Reinventing patterns
const data = await customFetchWithCustomCache();

// ✅ Good - Always handle errors
try {
  const data = await loadData();
} catch (error) {
  logger.error('feature', 'loadData', `Failed: ${error}`, { error });
  showError(error);
}

// ❌ Avoid - Ignoring errors
const data = await loadData(); // What if it fails?