openuispec 0.1.25 → 0.1.28

package/examples/taskflow/CLAUDE.md

@@ -0,0 +1,112 @@
+<!-- openuispec-rules-start -->
+<!-- openuispec-rules-version: 0.1.28 -->
+# OpenUISpec — AI Assistant Rules
+# ================================
+# This project uses OpenUISpec to define UI as a semantic spec.
+# Spec files are the single source of truth for all UI across platforms.
+# Targets: "ios", "android", "web"
+
+## IMPORTANT — Read the specification before working with spec files
+
+The spec format, file schemas, and generation rules are defined in the installed `openuispec` package.
+You MUST read the reference files listed below before creating, editing, or generating from any spec file.
+Do NOT guess the file format — skipping this step will produce invalid YAML that fails validation.
+
+**Find the package in this order:**
+1. `node_modules/openuispec/` (project dependency)
+2. Run `npm root -g` → `<prefix>/openuispec/` (global install)
+3. Online: `https://openuispec.rsteam.uz/llms-full.txt` (if not installed)
+
+**Reference files inside the package (read in this order):**
+1. `README.md` — schema tables, file format reference, root wrapper keys
+2. `spec/openuispec-v0.1.md` — full specification (contracts, layout, expressions, adaptive, etc.)
+3. `examples/taskflow/openuispec/` — complete working example with all file types
+4. `schema/` — JSON Schemas for every file type
+
+These files are updated with each package version. Always read from the installed package,
+not from cached or memorized content, to ensure you use the latest spec.
+
+## What is OpenUISpec
+OpenUISpec is a YAML-based spec format that describes an app's UI semantically — tokens, screens, flows, and platform overrides. AI reads the spec and generates native code (SwiftUI, Compose, React). AI reads native code and updates the spec. The spec is the sync layer between platforms.
+
+## Spec location
+- Spec root: `openuispec/`
+- Manifest: `openuispec/openuispec.yaml` — always read this first.
+- Tokens: `openuispec/tokens/`
+- Screens: `openuispec/screens/`
+- Flows: `openuispec/flows/`
+- Contracts: `openuispec/contracts/`
+- Platform: `openuispec/platform/`
+- Locales: `openuispec/locales/`
+
+**Note:** These are the default paths. Actual paths are in `includes:` in `openuispec.yaml` and may use relative paths. Always read `openuispec.yaml` to find the real directories.
+
+## If spec directories are empty (first-time setup)
+This means the project has existing UI code but hasn't been specced yet. Your job:
+
+1. **Read the spec first** — find and read `spec/openuispec-v0.1.md` from the installed package.
+2. **Find existing screens** — scan the codebase for UI screen files.
+3. **Create stubs** — for each screen, create `openuispec/screens/<name>.yaml` with:
+   ```yaml
+   screen_name:
+     semantic: "Brief description of what this screen does"
+     status: stub
+     layout:
+       type: scroll_vertical
+   ```
+4. **Extract tokens** — scan for colors, fonts, spacing and create files in `openuispec/tokens/`.
+5. **Update the manifest** — fill in `data_model` and `api.endpoints` in `openuispec/openuispec.yaml`.
+
+## OpenUISpec Source Of Truth
+
+OpenUISpec spec files are the primary source of truth for UI behavior across platforms.
+
+### Start from spec when:
+- the request changes screen structure
+- the request changes navigation
+- the request changes fields, actions, validation, or data binding
+- the request changes tokens, variants, contracts, flows, or localization
+- the request affects more than one platform
+- the request is phrased in product/UI terms rather than platform-code terms
+
+Spec-first workflow:
+1. Read `openuispec/openuispec.yaml` and the relevant spec files first.
+2. Update the spec first.
+3. Update the affected generated/native UI code to match the spec.
+4. Run `openuispec validate`.
+5. Run `openuispec validate semantic`.
+6. Run `openuispec drift --target <target> --explain` to inspect semantic changes since that target's baseline.
+7. Run `openuispec prepare --target <target>` to build the AI/developer work bundle for that target.
+8. Verify the affected UI targets build/run if possible.
+9. Only then run `openuispec drift --snapshot --target <target>` for affected targets, after that target output directory exists.
+10. Run `openuispec drift --target <target> --explain` again to confirm no spec changes remain for that target.
+11. Use `openuispec status` to see which other targets are still behind the updated spec.
+
+### Start from platform code when:
+- the change is platform-specific polish
+- the change is a local bug fix that does not alter shared semantic behavior
+- the request explicitly asks for an iOS-only, Android-only, or web-only adjustment
+
+Platform-first workflow:
+1. Update native/platform code.
+2. If the change affects shared semantics, sync the spec afterward.
+3. If the change is intentionally platform-specific, document it in `platform/*.yaml` when appropriate.
+
+### Never do this:
+- Do not snapshot drift immediately after changing spec unless the UI code has also been updated.
+- Do not treat `openuispec drift` as proof that generated UI matches the spec.
+- Do not skip `--explain` / `prepare` when another platform needs to catch up with shared spec changes.
+- Do not modify generated UI without checking whether the spec must change first.
+
+## CLI commands
+- `openuispec init` — scaffold a new spec project
+- `openuispec validate [group...]` — validate spec files against schemas
+- `openuispec validate semantic` — run semantic cross-reference linting
+- `openuispec drift --target <t>` — check for spec drift
+- `openuispec drift --target <t> --explain` — explain semantic spec drift since the target baseline
+- `openuispec drift --snapshot --target <t>` — snapshot current state after the target output exists
+- `openuispec prepare --target <t>` — build an AI-ready target update bundle
+- `openuispec status` — show cross-target baseline/drift status
+- `openuispec update-rules` — update AI rules to match installed package version
+- `openuispec drift --all` — include stubs in drift check
+<!-- openuispec-rules-end -->

package/examples/taskflow/generated/android/TaskFlow/README.md

@@ -0,0 +1,43 @@
+# TaskFlow Android Target
+
+This Android target was generated directly from the local `openuispec/` TaskFlow specification, without copying another sample project's output.
+
+## What is included
+
+- A lean Jetpack Compose app scaffold under `app/`
+- Adaptive navigation using spec breakpoints:
+  - `compact`: bottom navigation
+  - `regular` and `expanded`: navigation rail
+- Spec-derived screens:
+  - Home
+  - Task detail
+  - Projects
+  - Project detail
+  - Calendar stub
+  - Settings
+  - Profile edit
+- Spec-derived flows:
+  - Create task
+  - Edit task
+  - Assign task
+  - New project
+- Local sample data matching the spec's data model
+- English string resources derived from `openuispec/locales/en.json`
+- Theme colors based on `openuispec/tokens/color.yaml` and `themes.yaml`
+
+## Project notes
+
+- This is intentionally lean. It favors clear generated structure over a fully productionized architecture.
+- The app uses local Compose state instead of wiring real API clients.
+- The media-player custom contract is acknowledged in the spec but not implemented here because no screen in this minimal target renders a concrete media attachment asset.
+- No Gradle wrapper is checked in. Use a local Gradle installation or import the project into Android Studio and let it create the wrapper if needed.
+
+## Suggested verification
+
+From this directory:
+
+```bash
+gradle :app:assembleDebug
+```
+
+Or open `generated/android/TaskFlow` in Android Studio and run the app on an emulator.

package/examples/taskflow/generated/android/TaskFlow/app/build.gradle.kts

@@ -0,0 +1,76 @@
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+    id("org.jetbrains.kotlin.plugin.compose")
+}
+
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+android {
+    namespace = "uz.rsteam.taskflow"
+    compileSdk = 35
+
+    defaultConfig {
+        applicationId = "uz.rsteam.taskflow"
+        minSdk = 26
+        targetSdk = 35
+        versionCode = 1
+        versionName = "1.0.0"
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        vectorDrawables {
+            useSupportLibrary = true
+        }
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    buildFeatures {
+        compose = true
+    }
+
+    packaging {
+        resources {
+            excludes += "/META-INF/{AL2.0,LGPL2.1}"
+        }
+    }
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_17)
+    }
+}
+
+dependencies {
+    val composeBom = platform("androidx.compose:compose-bom:2024.10.01")
+
+    implementation(composeBom)
+    androidTestImplementation(composeBom)
+
+    implementation("androidx.core:core-ktx:1.15.0")
+    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.7")
+    implementation("androidx.activity:activity-compose:1.9.3")
+    implementation("androidx.compose.ui:ui")
+    implementation("androidx.compose.ui:ui-graphics")
+    implementation("androidx.compose.ui:ui-tooling-preview")
+    implementation("androidx.compose.material3:material3")
+    implementation("androidx.compose.material:material-icons-extended")
+    implementation("androidx.compose.foundation:foundation")
+
+    debugImplementation("androidx.compose.ui:ui-tooling")
+    debugImplementation("androidx.compose.ui:ui-test-manifest")
+}

package/examples/taskflow/generated/android/TaskFlow/app/proguard-rules.pro

@@ -0,0 +1 @@
+# Generated sample app. No custom ProGuard rules required.

package/examples/taskflow/generated/android/TaskFlow/app/src/main/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application
+        android:allowBackup="true"
+        android:label="@string/app_name"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.TaskFlow">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:theme="@style/Theme.TaskFlow">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

package/examples/taskflow/generated/android/TaskFlow/app/src/main/java/uz/rsteam/taskflow/MainActivity.kt

@@ -0,0 +1,19 @@
+package uz.rsteam.taskflow
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import uz.rsteam.taskflow.ui.theme.TaskFlowTheme
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        setContent {
+            TaskFlowTheme {
+                TaskFlowApp()
+            }
+        }
+    }
+}

package/examples/taskflow/generated/android/TaskFlow/app/src/main/java/uz/rsteam/taskflow/TaskFlowApp.kt

@@ -0,0 +1,283 @@
+package uz.rsteam.taskflow
+
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.CalendarMonth
+import androidx.compose.material.icons.outlined.Folder
+import androidx.compose.material.icons.outlined.Home
+import androidx.compose.material.icons.outlined.Settings
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.NavigationBar
+import androidx.compose.material3.NavigationBarItem
+import androidx.compose.material3.NavigationRail
+import androidx.compose.material3.NavigationRailItem
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import uz.rsteam.taskflow.model.NewProjectDraft
+import uz.rsteam.taskflow.model.Priority
+import uz.rsteam.taskflow.model.Project
+import uz.rsteam.taskflow.model.Route
+import uz.rsteam.taskflow.model.SampleData
+import uz.rsteam.taskflow.model.SheetState
+import uz.rsteam.taskflow.model.Task
+import uz.rsteam.taskflow.model.TaskEditorDraft
+import uz.rsteam.taskflow.model.TaskFilter
+import uz.rsteam.taskflow.model.TaskStatus
+import uz.rsteam.taskflow.model.TopLevelScreen
+import uz.rsteam.taskflow.ui.screens.CalendarScreen
+import uz.rsteam.taskflow.ui.screens.HomeScreen
+import uz.rsteam.taskflow.ui.screens.ProfileEditScreen
+import uz.rsteam.taskflow.ui.screens.ProjectDetailScreen
+import uz.rsteam.taskflow.ui.screens.ProjectsScreen
+import uz.rsteam.taskflow.ui.screens.SettingsScreen
+import uz.rsteam.taskflow.ui.screens.TaskDetailScreen
+import uz.rsteam.taskflow.ui.sheets.AssignUserSheet
+import uz.rsteam.taskflow.ui.sheets.NewProjectSheet
+import uz.rsteam.taskflow.ui.sheets.TaskEditorSheet
+import uz.rsteam.taskflow.ui.theme.TaskFlowTheme
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.util.UUID
+
+@Composable
+fun TaskFlowApp() {
+    val users = remember { SampleData.users }
+    val currentUser = users.first()
+    val projects = remember { mutableStateListOf<Project>().apply { addAll(SampleData.projects) } }
+    val tasks = remember { mutableStateListOf<Task>().apply { addAll(SampleData.tasks(currentUser)) } }
+
+    var route by remember { mutableStateOf<Route>(Route.TopLevel(TopLevelScreen.Home)) }
+    var sheetState by remember { mutableStateOf<SheetState?>(null) }
+    var searchQuery by remember { mutableStateOf("") }
+    var activeFilter by remember { mutableStateOf(TaskFilter.Today) }
+
+    TaskFlowTheme {
+        BoxWithConstraints {
+            val compact = maxWidth < 600.dp
+            val primaryColor = MaterialTheme.colorScheme.primary
+            val selectedTopLevel = when (val r = route) {
+                is Route.TopLevel -> r.screen
+                is Route.ProjectDetail -> TopLevelScreen.Projects
+                is Route.ProfileEdit -> TopLevelScreen.Settings
+                is Route.TaskDetail -> TopLevelScreen.Home
+            }
+
+            Scaffold(
+                containerColor = MaterialTheme.colorScheme.background,
+                bottomBar = {
+                    if (compact) {
+                        NavigationBar {
+                            TopLevelScreen.entries.forEach { item ->
+                                NavigationBarItem(
+                                    selected = item == selectedTopLevel,
+                                    onClick = { route = Route.TopLevel(item) },
+                                    icon = {
+                                        Icon(
+                                            when (item) {
+                                                TopLevelScreen.Home -> Icons.Outlined.Home
+                                                TopLevelScreen.Projects -> Icons.Outlined.Folder
+                                                TopLevelScreen.Calendar -> Icons.Outlined.CalendarMonth
+                                                TopLevelScreen.Settings -> Icons.Outlined.Settings
+                                            },
+                                            contentDescription = null
+                                        )
+                                    },
+                                    label = { Text(textFor(item)) }
+                                )
+                            }
+                        }
+                    }
+                },
+                floatingActionButton = {
+                    if (selectedTopLevel == TopLevelScreen.Home) {
+                        FloatingActionButton(onClick = { sheetState = SheetState.CreateTask }) {
+                            Text("+")
+                        }
+                    }
+                }
+            ) { innerPadding ->
+                Row(modifier = Modifier.fillMaxSize()) {
+                    if (!compact) {
+                        NavigationRail(modifier = Modifier.fillMaxHeight().navigationBarsPadding()) {
+                            TopLevelScreen.entries.forEach { item ->
+                                NavigationRailItem(
+                                    selected = item == selectedTopLevel,
+                                    onClick = { route = Route.TopLevel(item) },
+                                    icon = {
+                                        Icon(
+                                            when (item) {
+                                                TopLevelScreen.Home -> Icons.Outlined.Home
+                                                TopLevelScreen.Projects -> Icons.Outlined.Folder
+                                                TopLevelScreen.Calendar -> Icons.Outlined.CalendarMonth
+                                                TopLevelScreen.Settings -> Icons.Outlined.Settings
+                                            },
+                                            contentDescription = null
+                                        )
+                                    },
+                                    label = { Text(textFor(item)) }
+                                )
+                            }
+                        }
+                    }
+
+                    when (val currentRoute = route) {
+                        is Route.TopLevel -> when (currentRoute.screen) {
+                            TopLevelScreen.Home -> HomeScreen(
+                                currentUser = currentUser,
+                                projects = projects,
+                                tasks = tasks,
+                                activeFilter = activeFilter,
+                                searchQuery = searchQuery,
+                                onSearchChange = { searchQuery = it },
+                                onFilterChange = { activeFilter = it },
+                                onSelectTask = { route = Route.TaskDetail(it) },
+                                onCreateTask = { sheetState = SheetState.CreateTask }
+                            )
+                            TopLevelScreen.Projects -> ProjectsScreen(
+                                projects = projects.map { it.copy(taskCount = tasks.count { t -> t.projectId == it.id }) },
+                                onOpenProject = { route = Route.ProjectDetail(it) },
+                                onNewProject = { sheetState = SheetState.NewProject }
+                            )
+                            TopLevelScreen.Calendar -> CalendarScreen()
+                            TopLevelScreen.Settings -> SettingsScreen(
+                                currentUser = currentUser,
+                                preferences = uz.rsteam.taskflow.model.Preferences(),
+                                onPreferencesChange = {},
+                                onEditProfile = { route = Route.ProfileEdit }
+                            )
+                        }
+                        is Route.TaskDetail -> {
+                            val task = tasks.firstOrNull { it.id == currentRoute.taskId }
+                            if (task != null) {
+                                TaskDetailScreen(
+                                    task = task,
+                                    project = projects.firstOrNull { it.id == task.projectId },
+                                    onEdit = { sheetState = SheetState.EditTask(task.id) },
+                                    onToggleStatus = {
+                                        val idx = tasks.indexOfFirst { it.id == task.id }
+                                        if (idx >= 0) tasks[idx] = task.copy(
+                                            status = if (task.status == TaskStatus.Done) TaskStatus.Todo else TaskStatus.Done,
+                                            updatedAt = LocalDateTime.now()
+                                        )
+                                    },
+                                    onDelete = {
+                                        tasks.removeAll { it.id == task.id }
+                                        route = Route.TopLevel(TopLevelScreen.Home)
+                                    },
+                                    onProjectClick = { task.projectId?.let { route = Route.ProjectDetail(it) } },
+                                    onAssign = { sheetState = SheetState.AssignTask(task.id) }
+                                )
+                            }
+                        }
+                        is Route.ProjectDetail -> {
+                            val project = projects.firstOrNull { it.id == currentRoute.projectId }
+                            if (project != null) {
+                                ProjectDetailScreen(project = project, tasks = tasks.filter { it.projectId == project.id }, onOpenTask = {
+                                    route = Route.TaskDetail(it)
+                                })
+                            }
+                        }
+                        Route.ProfileEdit -> ProfileEditScreen(currentUser = currentUser) { _, _ ->
+                            route = Route.TopLevel(TopLevelScreen.Settings)
+                        }
+                    }
+                }
+            }
+
+            when (val sheet = sheetState) {
+                SheetState.CreateTask -> TaskEditorSheet(
+                    title = "New task",
+                    initial = TaskEditorDraft(priority = Priority.Medium),
+                    onDismiss = { sheetState = null },
+                    onSubmit = { draft ->
+                        tasks.add(0, toTask(draft, currentUser))
+                        sheetState = null
+                    }
+                )
+                is SheetState.EditTask -> {
+                    val task = tasks.firstOrNull { it.id == sheet.taskId }
+                    if (task != null) {
+                        TaskEditorSheet(
+                            title = "Edit task",
+                            initial = TaskEditorDraft(
+                                title = task.title,
+                                description = task.description ?: "",
+                                projectId = task.projectId,
+                                priority = task.priority,
+                                dueDate = task.dueDate?.toString() ?: "",
+                                tags = task.tags.joinToString(", "),
+                                assignToSelf = task.assignee?.id == currentUser.id
+                            ),
+                            onDismiss = { sheetState = null },
+                            onSubmit = { draft ->
+                                val idx = tasks.indexOfFirst { it.id == task.id }
+                                if (idx >= 0) tasks[idx] = task.copy(
+                                    title = draft.title,
+                                    description = draft.description.ifBlank { null },
+                                    priority = draft.priority,
+                                    dueDate = draft.dueDate.toLocalDateOrNull(),
+                                    projectId = draft.projectId,
+                                    tags = draft.tags.toTags(),
+                                    assignee = if (draft.assignToSelf) currentUser else null,
+                                    updatedAt = LocalDateTime.now()
+                                )
+                                sheetState = null
+                            }
+                        )
+                    }
+                }
+                SheetState.NewProject -> NewProjectSheet(
+                    onDismiss = { sheetState = null },
+                    onCreate = { draft: NewProjectDraft ->
+                        projects.add(Project(UUID.randomUUID().toString(), draft.name.trim(), primaryColor, Icons.Outlined.Folder, 0))
+                        sheetState = null
+                    }
+                )
+                is SheetState.AssignTask -> AssignUserSheet(users = users, onDismiss = { sheetState = null }) { user ->
+                    val idx = tasks.indexOfFirst { it.id == sheet.taskId }
+                    if (idx >= 0) tasks[idx] = tasks[idx].copy(assignee = user, updatedAt = LocalDateTime.now())
+                    sheetState = null
+                }
+                null -> Unit
+            }
+        }
+    }
+}
+
+private fun textFor(screen: TopLevelScreen) = when (screen) {
+    TopLevelScreen.Home -> "Tasks"
+    TopLevelScreen.Projects -> "Projects"
+    TopLevelScreen.Calendar -> "Calendar"
+    TopLevelScreen.Settings -> "Settings"
+}
+
+private fun toTask(draft: TaskEditorDraft, currentUser: uz.rsteam.taskflow.model.User): Task = Task(
+    id = UUID.randomUUID().toString(),
+    title = draft.title.trim(),
+    description = draft.description.trim().ifBlank { null },
+    status = TaskStatus.Todo,
+    priority = draft.priority,
+    dueDate = draft.dueDate.toLocalDateOrNull(),
+    projectId = draft.projectId,
+    tags = draft.tags.toTags(),
+    createdAt = LocalDateTime.now(),
+    updatedAt = LocalDateTime.now(),
+    assignee = if (draft.assignToSelf) currentUser else null
+)
+
+private fun String.toLocalDateOrNull(): LocalDate? = runCatching { LocalDate.parse(this) }.getOrNull()
+private fun String.toTags(): List<String> = split(",").map { it.trim() }.filter { it.isNotBlank() }

package/examples/taskflow/generated/android/TaskFlow/app/src/main/java/uz/rsteam/taskflow/model/DomainModels.kt

@@ -0,0 +1,106 @@
+package uz.rsteam.taskflow.model
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import uz.rsteam.taskflow.R
+import java.time.LocalDate
+import java.time.LocalDateTime
+
+enum class TopLevelScreen(val titleRes: Int) {
+    Home(R.string.nav_tasks),
+    Projects(R.string.nav_projects),
+    Calendar(R.string.nav_calendar),
+    Settings(R.string.nav_settings)
+}
+
+sealed interface Route {
+    data class TopLevel(val screen: TopLevelScreen) : Route
+    data class TaskDetail(val taskId: String) : Route
+    data class ProjectDetail(val projectId: String) : Route
+    data object ProfileEdit : Route
+}
+
+sealed interface SheetState {
+    data object CreateTask : SheetState
+    data class EditTask(val taskId: String) : SheetState
+    data object NewProject : SheetState
+    data class AssignTask(val taskId: String) : SheetState
+}
+
+enum class TaskFilter(val labelRes: Int) {
+    All(R.string.home_filter_all),
+    Today(R.string.home_filter_today),
+    Upcoming(R.string.home_filter_upcoming),
+    Done(R.string.home_filter_done)
+}
+
+enum class TaskStatus(val labelRes: Int) {
+    Todo(R.string.status_todo),
+    InProgress(R.string.status_in_progress),
+    Done(R.string.status_done)
+}
+
+enum class Priority(val labelRes: Int, val color: Color) {
+    Low(R.string.priority_low, Color(0xFF9CA3AF)),
+    Medium(R.string.priority_medium, Color(0xFF3B82D4)),
+    High(R.string.priority_high, Color(0xFFD4920E)),
+    Urgent(R.string.priority_urgent, Color(0xFFD43B3B))
+}
+
+data class User(
+    val id: String,
+    val name: String,
+    val firstName: String,
+    val email: String
+)
+
+data class Project(
+    val id: String,
+    val name: String,
+    val color: Color,
+    val icon: ImageVector,
+    val taskCount: Int
+)
+
+data class MediaAttachment(
+    val source: String,
+    val mediaType: String,
+    val title: String
+)
+
+data class Task(
+    val id: String,
+    val title: String,
+    val description: String?,
+    val status: TaskStatus,
+    val priority: Priority,
+    val dueDate: LocalDate?,
+    val projectId: String?,
+    val tags: List<String>,
+    val createdAt: LocalDateTime,
+    val updatedAt: LocalDateTime,
+    val assignee: User?,
+    val attachment: MediaAttachment? = null
+)
+
+data class Preferences(
+    val defaultPriority: Priority = Priority.Medium,
+    val notificationsEnabled: Boolean = true,
+    val remindersEnabled: Boolean = true
+)
+
+data class TaskEditorDraft(
+    val title: String = "",
+    val description: String = "",
+    val projectId: String? = null,
+    val priority: Priority = Priority.Medium,
+    val dueDate: String = "",
+    val tags: String = "",
+    val assignToSelf: Boolean = true
+)
+
+data class NewProjectDraft(
+    val name: String = "",
+    val colorName: String = "Indigo",
+    val iconName: String = "Folder"
+)