app/src/main/java/com/shub39/grit/tasks/presentation/TaskPageState.kt (2)

13-13: Nit: add a trailing newline at EOF.

Keeps diffs cleaner and satisfies common linters/ktlint rules.

---

9-12: Guard against in-place mutations of collections in @immutable state.

Because Map/List are read-only views, accidental in-place mutation of their backing data won’t be detected by Compose. Ensure producers always replace these with new instances (copy-on-write) rather than mutating in place. If this has bitten us before, consider persistent collections (kotlinx.collections.immutable) as a follow-up.

Would you like me to scan call sites to detect any .add, .remove, or casting-to-mutable on these properties?

app/src/main/java/com/shub39/grit/core/presentation/component/PageFill.kt (1)

11-13: Fix extra space and make PageFill more reusable (modifier + BoxScope).

• Remove the double space after fun.
• Expose modifier and alignment so callers can customize without wrapping.
• Accept BoxScope.() -> Unit to enable alignment APIs inside the slot.

Apply this diff:

@@
-// Wrapper to center everything
+// Wrapper to center everything
 @Composable
-fun  PageFill(
-    content: @Composable () -> Unit
-) {
-    Box(
-        modifier = Modifier.fillMaxSize(),
-        contentAlignment = Alignment.Center
-    ) { content() }
+fun PageFill(
+    modifier: Modifier = Modifier,
+    alignment: Alignment = Alignment.Center,
+    content: @Composable androidx.compose.foundation.layout.BoxScope.() -> Unit
+) {
+    Box(
+        modifier = modifier.fillMaxSize(),
+        contentAlignment = alignment,
+        content = content
+    )
 }

app/src/main/java/com/shub39/grit/tasks/presentation/ui/component/TaskCard.kt (2)

27-28: Remove unused experimental opt-ins.

This composable doesn’t reference APIs gated by ExperimentalFoundationApi or ExperimentalMaterial3ExpressiveApi. Keeping the opt-in widens the experimental surface area unnecessarily.

Apply this diff:

-@OptIn(ExperimentalFoundationApi::class, ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun TaskCard(

And remove the corresponding imports:

-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi

---

29-35: Add sensible defaults for modifier/shape and make reorderIcon optional.

Improves ergonomics and reduces boilerplate at call sites without breaking existing usages.

Apply this diff:

 fun TaskCard(
     task: Task,
     dragState: Boolean = false,
-    reorderIcon: @Composable () -> Unit,
-    shape: Shape,
-    modifier: Modifier
+    reorderIcon: @Composable () -> Unit = {},
+    shape: Shape = CardDefaults.shape,
+    modifier: Modifier = Modifier
 )

app/src/main/java/com/shub39/grit/habits/presentation/ui/component/AnalyticsCard.kt (1)

46-67: Provide a graceful pre-Android 12 (API < 31) fallback for the gated preview.

On older devices the content area is blank under the “Unlock Plus” button. Consider showing the content with an overlay scrim so users understand what’s being gated.

Apply this diff:

             if (!isUserSubscribed) {
                 Box(
                     contentAlignment = Alignment.Center,
                     modifier = Modifier
                         .height(200.dp)
                         .fillMaxWidth()
                 ) {
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                        Box(
-                            modifier = Modifier
-                                .matchParentSize()
-                                .blur(
-                                    radius = 10.dp,
-                                    edgeTreatment = BlurredEdgeTreatment.Unbounded
-                                )
-                        ) { content() }
-                    }
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                        Box(
+                            modifier = Modifier
+                                .matchParentSize()
+                                .blur(
+                                    radius = 10.dp,
+                                    edgeTreatment = BlurredEdgeTreatment.Unbounded
+                                )
+                        ) { content() }
+                    } else {
+                        // Fallback: show content with a dimmed scrim
+                        Box(modifier = Modifier.matchParentSize()) { content() }
+                        Box(
+                            modifier = Modifier
+                                .matchParentSize()
+                                .background(MaterialTheme.colorScheme.surface.copy(alpha = 0.85f))
+                        )
+                    }
 
                     Button(
                         onClick = onPlusClick
                     ) { Text(text = stringResource(R.string.unlock_plus)) }
                 }

Add missing import if needed:

+import androidx.compose.foundation.background

app/src/main/java/com/shub39/grit/core/presentation/component/InitialLoding.kt (2)

1-1: Typo in filename: rename to InitialLoading.kt.

Avoids confusion when searching and keeps naming consistent with the composable.

I can open a follow-up PR to rename the file if desired.

---

15-23: Allow modifier to be passed in for reuse and testability.

Enables callers to set size, background, or testTag without wrapping this composable.

Apply this diff:

 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun InitialLoading() {
-    Box(
-        modifier = Modifier
+fun InitialLoading(modifier: Modifier = Modifier) {
+    Box(
+        modifier = modifier
             .fillMaxSize()
             .background(MaterialTheme.colorScheme.background),
         contentAlignment = Alignment.Center
     ) {
         ContainedLoadingIndicator()
     }
 }

app/src/main/java/com/shub39/grit/habits/presentation/ui/component/HabitCard.kt (3)

172-188: Reduce O(n) scans in day rendering by precomputing a date set.
dayContent currently scans statusList 3x per day cell. Precompute a HashSet for O(1) lookups.

@@
-    val weekState = rememberWeekCalendarState(
+    val weekState = rememberWeekCalendarState(
         startDate = habit.time.toLocalDate().minusMonths(12),
         endDate = LocalDate.now(),
         firstVisibleWeekDate = LocalDate.now(),
         firstDayOfWeek = startingDay
     )
+
+    // Precompute for O(1) membership checks in the calendar
+    val doneDates = remember(statusList) {
+        statusList.map { it.date }.toHashSet()
+    }
@@
-            dayContent = { weekDay ->
-                val done = statusList.any { it.date == weekDay.date }
+            dayContent = { weekDay ->
+                val done = weekDay.date in doneDates
@@
-                                val donePrevious =
-                                    statusList.any { it.date == weekDay.date.minusDays(1) }
-                                val doneAfter =
-                                    statusList.any { it.date == weekDay.date.plusDays(1) }
+                                val donePrevious = weekDay.date.minusDays(1) in doneDates
+                                val doneAfter = weekDay.date.plusDays(1) in doneDates

---

60-66: Nit: label name mismatch for animateColorAsState.
The debug label says "cardBackground" but this state is for content color.

-    val cardContent by animateColorAsState(
+    val cardContent by animateColorAsState(
         targetValue = when (completed) {
             true -> MaterialTheme.colorScheme.onPrimaryContainer
             else -> MaterialTheme.colorScheme.onSurface
         },
-        label = "cardBackground"
+        label = "cardContent"
     )

---

225-229: Localize weekday label instead of truncating enum name.
Using getDisplayName honors locale and proper casing.

-                        Text(
-                            text = weekDay.date.dayOfWeek.toString().take(3),
+                        Text(
+                            text = weekDay.date.dayOfWeek.getDisplayName(
+                                java.time.format.TextStyle.SHORT,
+                                java.util.Locale.getDefault()
+                            ),

Add imports if not present:

import java.time.format.TextStyle
import java.util.Locale

app/src/main/java/com/shub39/grit/habits/presentation/util.kt (2)

15-25: Fix naming for consistency: habitStatuses.
Minor readability improvement; positional call sites remain unaffected.

-fun prepareLineChartData(
-    firstDay: DayOfWeek,
-    habitstatuses: List<HabitStatus>
-): List<Double> {
+fun prepareLineChartData(
+    firstDay: DayOfWeek,
+    habitStatuses: List<HabitStatus>
+): List<Double> {
@@
-    val habitCompletionByWeek = habitstatuses
+    val habitCompletionByWeek = habitStatuses

---

42-68: Optionally align weekday bar order with user’s starting day.
This makes the bar chart match the calendar/week configuration.

-fun prepareWeekDayData(
-    dates: List<LocalDate>,
-    lineColor: Color
-): List<Bars> {
+fun prepareWeekDayData(
+    firstDay: DayOfWeek,
+    dates: List<LocalDate>,
+    lineColor: Color
+): List<Bars> {
@@
-    val weekdayBars = DayOfWeek.entries.map { dayOfWeek ->
+    val orderedDays = DayOfWeek.entries.dropWhile { it != firstDay } +
+        DayOfWeek.entries.takeWhile { it != firstDay }
+    val weekdayBars = orderedDays.map { dayOfWeek ->

Apply at the call site in OverallAnalytics.kt:

-    val weeklyBreakdownData =
-        prepareWeekDayData(state.habitsWithStatuses.values.flatten().map { it.date }, primary)
+    val weeklyBreakdownData = prepareWeekDayData(
+        state.startingDay,
+        state.habitsWithStatuses.values.flatten().map { it.date },
+        primary
+    )

app/src/main/java/com/shub39/grit/habits/presentation/ui/section/OverallAnalytics.kt (1)

77-80: Cache heavy derived datasets with remember.
These recompute on every recomposition; memoize to cut work.

-    val heatMapData = prepareHeatMapData(state.habitsWithStatuses)
-    val weeklyBreakdownData =
-        prepareWeekDayData(state.habitsWithStatuses.values.flatten().map { it.date }, primary)
+    val heatMapData = remember(state.habitsWithStatuses) {
+        prepareHeatMapData(state.habitsWithStatuses)
+    }
+    val weeklyBreakdownData = remember(state.habitsWithStatuses, primary) {
+        // If you adopt the firstDay param change, add it here.
+        prepareWeekDayData(
+            state.habitsWithStatuses.values.flatten().map { it.date },
+            primary
+        )
+    }

If you implement the optional signature change suggested in util.kt, call it as:

prepareWeekDayData(state.startingDay, state.habitsWithStatuses.values.flatten().map { it.date }, primary)

app/src/main/java/com/shub39/grit/core/presentation/settings/ui/section/Backup.kt (3)

72-76: Localize icon content descriptions (avoid hardcoded English).

Hardcoded contentDescription strings (“Navigate Back”, “Start”, “Done”, “Fail”) hinder i18n and consistency. Prefer stringResource. If keys don’t exist yet, please add them to strings.xml.

-                    Icon(
-                        imageVector = Icons.AutoMirrored.Default.ArrowBack,
-                        contentDescription = "Navigate Back"
-                    )
+                    Icon(
+                        imageVector = Icons.AutoMirrored.Default.ArrowBack,
+                        contentDescription = stringResource(R.string.navigate_back)
+                    )
@@
-                                ExportState.IDLE -> Icon(
-                                    painter = painterResource(R.drawable.round_play_arrow_24),
-                                    contentDescription = "Start"
-                                )
+                                ExportState.IDLE -> Icon(
+                                    painter = painterResource(R.drawable.round_play_arrow_24),
+                                    contentDescription = stringResource(R.string.start)
+                                )
@@
-                                ExportState.EXPORTED -> Icon(
-                                    imageVector = Icons.Default.CheckCircle,
-                                    contentDescription = "Done"
-                                )
+                                ExportState.EXPORTED -> Icon(
+                                    imageVector = Icons.Default.CheckCircle,
+                                    contentDescription = stringResource(R.string.done)
+                                )
@@
-                                    RestoreState.IDLE -> Icon(
-                                        painter = painterResource(R.drawable.round_play_arrow_24),
-                                        contentDescription = "Start"
-                                    )
+                                    RestoreState.IDLE -> Icon(
+                                        painter = painterResource(R.drawable.round_play_arrow_24),
+                                        contentDescription = stringResource(R.string.start)
+                                    )
@@
-                                    RestoreState.RESTORED -> Icon(
-                                        imageVector = Icons.Default.CheckCircle,
-                                        contentDescription = "Done"
-                                    )
+                                    RestoreState.RESTORED -> Icon(
+                                        imageVector = Icons.Default.CheckCircle,
+                                        contentDescription = stringResource(R.string.done)
+                                    )
@@
-                                    RestoreState.FAILURE -> Icon(
-                                        imageVector = Icons.Default.Warning,
-                                        contentDescription = "Fail"
-                                    )
+                                    RestoreState.FAILURE -> Icon(
+                                        imageVector = Icons.Default.Warning,
+                                        contentDescription = stringResource(R.string.fail)
+                                    )

Also applies to: 101-105, 112-116, 149-166

---

96-105: Allow re-export without forcing a manual reset.

After a successful export, the button remains disabled (only enabled on IDLE). Consider enabling unless EXPORTING so users can export again in the same session.

-                            enabled = state.backupState.exportState == ExportState.IDLE
+                            enabled = state.backupState.exportState != ExportState.EXPORTING

---

52-56: Persist selection across configuration changes; verify persistable URI permissions.

If the user selects a file and rotates the device, the remembered Uri resets. Use rememberSaveable. Also, ensure that restore logic takes persistable read permission if the Uri needs to be accessed beyond the immediate call.

+import androidx.compose.runtime.saveable.rememberSaveable
@@
-    var uri by remember { mutableStateOf<Uri?>(null) }
+    var uri by rememberSaveable { mutableStateOf<Uri?>(null) }

Would you like me to add a call to contentResolver.takePersistableUriPermission() in the ViewModel/onAction handler if long-lived access is required?

app/src/main/java/com/shub39/grit/core/presentation/settings/ui/section/AboutLibraries.kt (1)

42-45: Localize the nav icon content description.

Replace the hardcoded “Navigate Back” with a stringResource for i18n consistency.

-                    Icon(
-                        imageVector = Icons.AutoMirrored.Default.ArrowBack,
-                        contentDescription = "Navigate Back"
-                    )
+                    Icon(
+                        imageVector = Icons.AutoMirrored.Default.ArrowBack,
+                        contentDescription = stringResource(R.string.navigate_back)
+                    )

app/src/main/java/com/shub39/grit/habits/presentation/ui/section/HabitsList.kt (4)

368-369: Fix off-by-one: title/description max length is inconsistent with labels.

The button enables at <20 and <50 while the labels consider <=20 and <=50 valid. Align to <= for both.

-                enabled = newHabitName.isNotBlank() && newHabitName.length < 20 && newHabitDescription.length < 50,
+                enabled = newHabitName.isNotBlank() && newHabitName.length <= 20 && newHabitDescription.length <= 50,

---

85-86: Reduce unnecessary resets of the reorder list state.

Using remember(state) will reset reorderableHabits on any state change, even unrelated ones. Key it to the derived habits list instead.

-    var reorderableHabits by remember(state) { mutableStateOf(habits) }
+    var reorderableHabits by remember(habits) { mutableStateOf(habits) }

---

240-241: Stronger duplicate detection (trim + case-insensitive).

Prevents accidental duplicates like “Workout” vs “workout” or trailing spaces.

-        val isHabitPresent = { state.habitsWithStatuses.any { it.key.title == newHabitName } }
+        val isHabitPresent = {
+            val normalized = newHabitName.trim()
+            state.habitsWithStatuses.any { it.key.title.equals(normalized, ignoreCase = true) }
+        }

Optionally also trim the title when constructing Habit to keep stored data clean.

---

130-134: A11y: add contentDescription to the reorder handle icon.

Toggle button content is currently decorative to TalkBack. Provide a localized description.

-                            Icon(
-                                painter = painterResource(R.drawable.baseline_reorder_24),
-                                contentDescription = null
-                            )
+                            Icon(
+                                painter = painterResource(R.drawable.baseline_reorder_24),
+                                contentDescription = stringResource(R.string.reorder_items)
+                            )

If the string key doesn’t exist, please add it.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/EditCategories.kt (1)

109-109: Minor readability nit: name the key param instead of shadowing with it

Using it twice (itemsIndexed’s lambda and key lambda) hurts readability.

-            itemsIndexed(categories, key = { _, it -> it.id }) { index, category ->
+            itemsIndexed(categories, key = { _, category -> category.id }) { index, category ->

app/src/main/java/com/shub39/grit/core/presentation/settings/ui/component/AboutApp.kt (1)

63-69: Localize hardcoded strings for i18n/accessibility

“Grit”, “Discord”, and “Github” are hardcoded; prefer stringResource for localization and a11y consistency.

Example:

-                Text(
-                    text = "Grit",
+                Text(
+                    text = stringResource(R.string.app_name),
                 )
...
-                    onClick = { uriHandler.openUri("https://discord.gg/nxA2hgtEKf") }
+                    onClick = { uriHandler.openUri("https://discord.gg/nxA2hgtEKf") }
                 ) {
                     Icon(
-                        imageVector = FontAwesomeIcons.Brands.Discord,
-                        contentDescription = "Discord",
+                        imageVector = FontAwesomeIcons.Brands.Discord,
+                        contentDescription = stringResource(R.string.discord),
                     )
                 }
...
                     Icon(
-                        imageVector = FontAwesomeIcons.Brands.Github,
-                        contentDescription = "Github",
+                        imageVector = FontAwesomeIcons.Brands.Github,
+                        contentDescription = stringResource(R.string.github),
                     )

Please confirm R.string.app_name/discord/github exist; I can add them if needed.

Also applies to: 73-93, 100-135

app/src/main/java/com/shub39/grit/core/presentation/settings/ui/section/RootPage.kt (2)

94-114: Prefer localized content descriptions for icons

Hardcoded contentDescription strings (“Grit Plus”, “Navigate”, “Backup”, “About Libraries”) should use stringResource to align with the rest of the screen.

Example:

-                        contentDescription = "Grit Plus"
+                        contentDescription = stringResource(R.string.grit_plus)

Also applies to: 244-263, 266-286, 289-304

---

60-63: Check biometric check timing across config changes

LaunchedEffect(Unit) runs once per composition; if context-dependent availability can change on configuration updates, consider keying on context as well.

-    LaunchedEffect(Unit) {
+    LaunchedEffect(context) {
         onAction(SettingsAction.OnCheckBiometric(context))
     }

app/src/main/java/com/shub39/grit/habits/presentation/ui/section/AnalyticsPage.kt (3)

127-138: Calendar states may not reflect startingDay changes

rememberHeatMapCalendarState/rememberCalendarState are created once; if state.startingDay changes at runtime, the states may not update. Consider keying them on state.startingDay.

-    val heatMapState = rememberHeatMapCalendarState(
+    val heatMapState = remember(state.startingDay) {
+        rememberHeatMapCalendarState(
             startMonth = currentMonth.minusMonths(12),
             endMonth = currentMonth,
             firstVisibleMonth = currentMonth,
             firstDayOfWeek = state.startingDay
-    )
+        )
+    }
-    val calendarState = rememberCalendarState(
+    val calendarState = remember(state.startingDay) {
+        rememberCalendarState(
             startMonth = currentMonth.minusMonths(12),
             endMonth = currentMonth,
             firstVisibleMonth = currentMonth,
             firstDayOfWeek = state.startingDay
-    )
+        )
+    }

---

241-271: Localize content descriptions for icons

Hardcoded contentDescription strings (“Warning”, “Delete Habit”, “Edit Habit”, “Add Time”) should use stringResource for i18n and a11y.

Example:

-                contentDescription = "Delete Habit"
+                contentDescription = stringResource(R.string.delete_habit)

Also applies to: 421-455

---

275-285: Persist edit dialog state across config changes (optional)

Using rememberSaveable for editDialog/timePickerDialog/new* fields will preserve state on rotation/process death.

-    if (editDialog) {
-        var newHabitTitle by remember { mutableStateOf(currentHabit.title) }
+    if (editDialog) {
+        var newHabitTitle by rememberSaveable { mutableStateOf(currentHabit.title) }
         ...
-        var timePickerDialog by remember { mutableStateOf(false) }
+        var timePickerDialog by rememberSaveable { mutableStateOf(false) }

Note: add import androidx.compose.runtime.saveable.rememberSaveable.

app/src/main/java/com/shub39/grit/habits/presentation/HabitsGraph.kt (1)

62-67: Avoid stacking duplicate destinations by using launchSingleTop on navigate.

If users tap repeatedly, the typed destinations can stack in the back stack. Use launchSingleTop to keep a single instance.

-                onNavigateToOverallAnalytics = { navController.navigate(HabitRoutes.OverallAnalytics) },
-                onNavigateToAnalytics = { navController.navigate(HabitRoutes.HabitAnalytics) }
+                onNavigateToOverallAnalytics = {
+                    navController.navigate(HabitRoutes.OverallAnalytics) {
+                        launchSingleTop = true
+                    }
+                },
+                onNavigateToAnalytics = {
+                    navController.navigate(HabitRoutes.HabitAnalytics) {
+                        launchSingleTop = true
+                    }
+                }

app/src/main/java/com/shub39/grit/core/presentation/settings/SettingsGraph.kt (2)

73-76: Prevent duplicate subpages by using launchSingleTop in navigate calls.

Navigating from RootPage can push duplicates if tapped repeatedly.

-                onNavigateToLookAndFeel = { navController.navigate(SettingsRoutes.LookAndFeel) },
-                onNavigateToBackup = { navController.navigate(SettingsRoutes.Backup) },
-                onNavigateToAboutLibraries = { navController.navigate(SettingsRoutes.AboutLibraries) },
+                onNavigateToLookAndFeel = {
+                    navController.navigate(SettingsRoutes.LookAndFeel) { launchSingleTop = true }
+                },
+                onNavigateToBackup = {
+                    navController.navigate(SettingsRoutes.Backup) { launchSingleTop = true }
+                },
+                onNavigateToAboutLibraries = {
+                    navController.navigate(SettingsRoutes.AboutLibraries) { launchSingleTop = true }
+                },

---

103-119: Scope the preview to file only.

Mark Preview() as private to avoid unnecessarily exporting a top-level symbol.

-@Preview
-@Composable
-fun Preview() {
+@Preview
+@Composable
+private fun Preview() {

app/src/main/java/com/shub39/grit/app/Grit.kt (1)

75-87: Use graph startDestination for popUpTo to simplify and harden bottom-bar navigation.

Hard-coding popUpTo based on a setting can be brittle. Using the graph’s start destination is the canonical pattern and works even if the start page changes later.

-    val navigator = { route: Routes ->
-        if (currentRoute != route) {
-            navController.navigate(route) {
-                launchSingleTop = true
-                popUpTo(
-                    when (settingsState.startingPage) {
-                        Pages.Habits -> Routes.HabitsPages
-                        Pages.Tasks -> Routes.TaskPages
-                    }
-                ) { saveState = true }
-                restoreState = true
-            }
-        }
-    }
+    val navigator = { route: Routes ->
+        if (currentRoute != route) {
+            navController.navigate(route) {
+                launchSingleTop = true
+                // pop up to the graph's start destination and preserve state
+                popUpTo(navController.graph.startDestinationId) { saveState = true }
+                restoreState = true
+            }
+        }
+    }

Note: If you prefer typed popUpTo, you can keep the current API but drive the target from a single source of truth, or use findStartDestination().id for equivalent behavior.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (2)

221-223: Stability tweak: derive remember key from category/tasks, not whole state.

remember(state) causes unnecessary resets of reorderableTasks on unrelated state changes.

-                    var reorderableTasks by remember(state) { mutableStateOf(tasks) }
+                    var reorderableTasks by remember(state.currentCategory, tasks) { mutableStateOf(tasks) }

---

490-494: No-op keyboardActions; either handle IME action or remove.

newTitle.plus("\n") and newTask.plus("\n") have no effect. Prefer onDone with ImeAction.Done, or drop keyboardActions.

-                keyboardOptions = KeyboardOptions.Default.copy(
-                    capitalization = KeyboardCapitalization.Sentences,
-                    imeAction = ImeAction.None
-                ),
-                keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTitle.plus("\n")
-                    }
-                ),
+                keyboardOptions = KeyboardOptions.Default.copy(
+                    capitalization = KeyboardCapitalization.Sentences,
+                    imeAction = ImeAction.Done
+                ),
+                keyboardActions = KeyboardActions(
+                    onDone = { /* optionally hide keyboard or advance focus */ }
+                ),

-                keyboardOptions = KeyboardOptions.Default.copy(
-                    capitalization = KeyboardCapitalization.Sentences,
-                    imeAction = ImeAction.None
-                ),
-                keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTask.plus("\n")
-                    }
-                ),
+                keyboardOptions = KeyboardOptions.Default.copy(
+                    capitalization = KeyboardCapitalization.Sentences,
+                    imeAction = ImeAction.Done
+                ),
+                keyboardActions = KeyboardActions(
+                    onDone = { /* optionally hide keyboard or submit */ }
+                ),

Also applies to: 579-582

app/src/main/java/com/shub39/grit/tasks/presentation/TasksGraph.kt (1)

27-28: Avoid symbol shadowing between route object and screen composable by aliasing the import

Both the route (TasksRoutes.EditCategories) and the composable screen (EditCategories) share the same simple name, which can be confusing in reviews and refactors. Aliasing the screen import keeps intent crystal clear.

Apply:

-import com.shub39.grit.tasks.presentation.ui.section.EditCategories
+import com.shub39.grit.tasks.presentation.ui.section.EditCategories as EditCategoriesScreen

And update the call site:

-            EditCategories(
+            EditCategoriesScreen(
                 state = state,
                 onAction = onAction,
                 onNavigateBack = { navController.navigateUp() }
             )

Also applies to: 67-73

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

app/src/main/java/com/shub39/grit/core/presentation/component/PageFill.kt (1)

1-1: Package move looks good.

Matches the components→component reorg across the codebase.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/component/TaskCard.kt (1)

1-1: Package move LGTM.

Matches the ui.component reorg; imports will resolve accordingly.

app/src/main/java/com/shub39/grit/habits/presentation/ui/component/AnalyticsCard.kt (1)

1-1: Package move LGTM.

Consistent with ui.component reorg; dependent imports in ui.section appear updated.

app/src/main/java/com/shub39/grit/core/presentation/component/InitialLoding.kt (1)

1-1: Package move LGTM.

Aligns with components→component consolidation.

app/src/main/java/com/shub39/grit/app/MainActivity.kt (1)

118-126: Confirm UX on biometric cancellation (finishing the Activity).
On user cancel or negative button, you toast and then call finish(). If the intended UX is to keep the app open but locked, consider returning to the lock screen instead of exiting.

app/src/main/java/com/shub39/grit/core/presentation/component/Empty.kt (1)

1-1: Package rename looks correct and consistent with the reorg.
No functional changes; call sites should continue to work with the new path.

app/src/main/java/com/shub39/grit/core/presentation/settings/ui/section/Backup.kt (1)

1-1: Namespace/import migration looks consistent with the project reorg.

The package move and PageFill import update align with the plural→singular component consolidation. No functional changes introduced here.

Also applies to: 37-37

app/src/main/java/com/shub39/grit/core/presentation/settings/ui/section/AboutLibraries.kt (1)

1-1: Package/import updates look good.

Matches the broader move to settings.ui.section and core.presentation.component.

Also applies to: 22-22

app/src/main/java/com/shub39/grit/core/presentation/component/ColorPickerDialog.kt (1)

1-1: Package move aligns with core component consolidation.

No functional changes; dialog composition and callbacks look correct.

app/src/main/java/com/shub39/grit/core/presentation/component/GritBottomSheet.kt (1)

1-1: Namespace update looks good; API remains stable.

Sheet configuration (max width, skip partial) and Column contract are sensible defaults.

app/src/main/java/com/shub39/grit/core/presentation/component/GritDialog.kt (1)

1-1: Package rename to singular namespace looks good

This aligns with the broader reorg (components → component). No functional changes; API remains stable.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/EditCategories.kt (3)

1-1: Package move to ui.section is consistent with the reorganisation

Matches the new module layout; no API/behavior change introduced here.

---

52-55: Updated imports to singular component package

GritBottomSheet/GritDialog/PageFill import paths are correct post-move.

---

239-245: Ignore the UpdateCategory suggestion – AddCategory is already an upsert

The TaskPageAction.AddCategory action calls repo.upsertCategory, and because category.copy(name = name) preserves the existing id, it updates rather than duplicates. There is no existing UpdateCategory or RenameCategory, and introducing one isn’t necessary for correctness.

• In TaskPageAction.kt (lines 7–8), data class AddCategory(val category: Category) is the sole category‐upsert action.
• In TasksViewModel.kt (lines 59–63), is TaskPageAction.AddCategory invokes upsertCategory(action.category), which updates by id.
• If you find the name confusing, you could refactor AddCategory→UpsertCategory in a follow-up change, but it isn’t required now.

Likely an incorrect or invalid review comment.

app/src/main/java/com/shub39/grit/core/presentation/settings/ui/component/AboutApp.kt (1)

1-1: Package path updated to settings.ui.component is consistent

Matches the settings reorg; usage in RootPage is updated accordingly.

app/src/main/java/com/shub39/grit/core/presentation/settings/ui/section/RootPage.kt (1)

1-1: Namespace/import updates are correct

PageFill import moved to singular; AboutApp is correctly sourced from settings.ui.component.

Also applies to: 37-38, 40-41

app/src/main/java/com/shub39/grit/habits/presentation/HabitsGraph.kt (2)

22-29: Rename to HabitsGraph and component/ui.section import migration look consistent.

The API rename + typed navigation setup align with the PR’s re-organization and other graphs. No functional concerns here.

Also applies to: 47-50

---

139-145: No action required: HabitStatus.id has a default value
The HabitStatus data class declares id: Long = 0, so calling HabitStatus(habitId = habit.id, date = it.date) without supplying an id is valid and will default to 0. No changes are needed here.

app/src/main/java/com/shub39/grit/core/presentation/settings/SettingsGraph.kt (1)

20-27: Settings → SettingsGraph migration and component/ui.section imports look good.

Typed routes and PageFill usage are consistent with the rest of the app graphs.

Also applies to: 44-47, 114-117

app/src/main/java/com/shub39/grit/core/presentation/settings/ui/section/LookAndFeelPage.kt (1)

1-1: Package + component import reorg looks correct.

Also applies to: 77-80

app/src/main/java/com/shub39/grit/app/Grit.kt (1)

36-38: Graph composable adoption (TasksGraph/SettingsGraph/HabitsGraph) is consistent and correct.

Also applies to: 157-161, 166-169, 178-181

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (1)

70-73: Import reorg to component/ui and TaskCard new location looks good.

Also applies to: 79-79

app/src/main/java/com/shub39/grit/tasks/presentation/TasksGraph.kt (3)

117-129: LGTM: Preview updated to use TasksGraph after rename

The preview references the renamed composable and compiles the happy path interaction. Looks good.

---

22-22: ✅ Migration Complete — No Remaining Old Imports Found

I reran a repository-wide search for any import com.shub39.grit.core.presentation.components.PageFill references across all Kotlin files (excluding build artifacts) and found zero matches. The singular component.PageFill import is now consistently used throughout the codebase. No further action is needed.

---

41-45: Rename completed: no stale Tasks references found

Verified via project-wide search that there are

• no remaining imports of com.shub39.grit.tasks.presentation.Tasks
• no unqualified calls to Tasks(...)
• all call sites now reference TasksGraph(...) (in TasksGraph.kt and Grit.kt)

The rename is fully applied—no further changes needed here.

gradle/libs.versions.toml (2)

21-21: Jetpack Compose UI = "1.9.0" — verify this version exists and align with Navigation & Material3; consider migrating to the Compose BOM.

Hard-pinning individual Compose artifacts often creates drift. The BOM ensures consistent, supported coordinates across ui, material3, tooling, etc.

Option A — adopt Compose BOM in the version catalog and drop per-artifact versions:

• Add a BOM alias (version managed once):

  [toml]
  [versions]
  composeBom = "REPLACE_WITH_PUBLISHED_BOM"

  [libraries]
  androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }

• Remove version.ref from androidx-ui, ui-graphics, ui-tooling, ui-tooling-preview, material3, and navigation-compose, and import the BOM in Gradle:

  dependencies {
  implementation(platform(libs.androidx.compose.bom))
  implementation(libs.androidx.ui)
  implementation(libs.androidx.ui.graphics)
  implementation(libs.androidx.ui.tooling.preview)
  implementation(libs.androidx.material3)
  implementation(libs.androidx.navigation.compose)
  debugImplementation(libs.androidx.ui.tooling)
  }

If you prefer to keep explicit versions, please confirm that androidx.compose.ui:ui:1.9.0 is published and compatible with your Material3 and Navigation versions using the script in the next comment. I can generate an exact BOM version once you confirm the target Compose train.

---

13-13: Alpha/stable mix: Material3 "1.5.0-alpha02" + Navigation "2.9.3" — double-check train compatibility.

Mixing alpha M3 with different generation Navigation and a possibly out-of-train Compose UI can cause API/ABI conflicts or missing symbols at runtime.

• Prefer keeping Material3, Compose UI, and Navigation on the same release train (via BOM).
• If you need an alpha M3 feature (e.g., Theme.seedColor previews), fix the train via BOM and only override the specific artifact if necessary, keeping others within the same snapshot line.

Use the dependency verification script below (next comment) to confirm these versions exist and co-resolve cleanly.

Also applies to: 16-16

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

gradle/libs.versions.toml (3)

3-5: Third-party dependencies verified and published

All of the updated coordinates have been confirmed in their respective Maven repositories—no missing versions detected. Feel free to proceed with merging.

---

11-12: Kotlin & KSP Version Verification Complete

• Verified on Maven Central:
  • org.jetbrains.kotlin:kotlin-gradle-plugin 2.2.10 ✅
  • com.google.devtools.ksp:com.google.devtools.ksp.gradle.plugin 2.2.10-2.0.2 ✅
  • com.google.devtools.ksp:symbol-processing-api 2.2.10-2.0.2 ✅

These artifacts are published and the Kotlin 2.2.10 / KSP 2.2.10-2.0.2 pairing is valid. No further changes are required here.

---

2-2: AGP 8.12.1 Verified and Compatible

Your script confirms that com.android.tools.build:gradle:8.12.1 is published on Google Maven and your Gradle wrapper is set to version 8.13. According to the official Android Gradle plugin release notes, AGP 8.12.x requires Gradle 8.13 as the minimum supported version (developer.android.com). You can safely retain

agp = "8.12.1"

in gradle/libs.versions.toml.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (1)

270-278: Move completed task using the working list, not the original snapshot.

This recreates the list from tasks, which can discard in-flight reorders and misplace items. Operate on reorderableTasks instead. Also, prefer using the target list’s size when appending to the end to avoid off-by-one coupling to the old list size.

Apply this diff:

-                                                        reorderableTasks =
-                                                            tasks.toMutableList().apply {
-                                                                add(reorderableTasks.size - 1, removeAt(index))
-                                                            }
+                                                        reorderableTasks =
+                                                            reorderableTasks.toMutableList().apply {
+                                                                // remove from current position and append to end
+                                                                add(size, removeAt(index))
+                                                            }

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (3)

166-175: Avoid persisting the original snapshot on category switch.

onClick sends ReorderTasks(tasks.mapIndexed { ... }), which persists the original snapshot, not the user’s working order. Either:

• Remove this call and rely on drag-stop/complete-tick flows to persist, or
• Hoist reorderableTasks so it’s available here (or move the chips into the same scope) and persist the working list instead.

If you keep the flush here, ensure it uses the current working list. Otherwise, consider removing it to avoid persisting stale ordering.

---

490-494: No-op KeyboardActions handlers.

newTitle.plus("\n") / newTask.plus("\n") returns a new string and doesn’t change state. Either assign the result or remove the handler to avoid confusion. Given both text fields are single-line or have ImeAction.None, removing is fine.

Example cleanup:

-                keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTitle.plus("\n")
-                    }
-                ),
+                // No keyboardActions: single-line editing

Also applies to: 579-581

---

191-195: Localize content descriptions.

Hardcoded English strings (“Add Category”, “Edit Categories”, “Drag”, “Warning”, “Add”, “Edit”) should use stringResource(...) for i18n consistency with the rest of the screen.

Example:

- contentDescription = "Add Category"
+ contentDescription = stringResource(R.string.add_category)

Apply similarly to the other icons above.

Also applies to: 207-211, 245-247, 344-347, 389-391, 458-460, 546-548

app/src/main/java/com/shub39/grit/core/presentation/component/InitialLoading.kt (3)

15-19: Expose a Modifier parameter for composability and reuse.

Standard Compose convention: accept modifier: Modifier = Modifier to let callers control size/placement without forking this composable.

Apply:

-@Composable
-fun InitialLoading() {
+@Composable
+fun InitialLoading(modifier: Modifier = Modifier) {
     Box(
-        modifier = Modifier
-            .fillMaxSize()
-            .background(MaterialTheme.colorScheme.background),
+        modifier = modifier
+            .fillMaxSize()
+            .background(MaterialTheme.colorScheme.background),
         contentAlignment = Alignment.Center
     ) {

---

22-22: Add basic a11y semantics so TalkBack announces progress.

Annotate the indicator with a polite live region and a descriptive label; this improves accessibility on the initial loading screen.

Apply:

-        ContainedLoadingIndicator()
+        ContainedLoadingIndicator(
+            modifier = Modifier.semantics {
+                contentDescription = "Loading"
+                liveRegion = LiveRegionMode.Polite
+            }
+        )

Add imports (outside the selected range):

import androidx.compose.ui.semantics.LiveRegionMode
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.liveRegion
import androidx.compose.ui.semantics.semantics

Optionally, source the label from strings for localization and pass it as a parameter.

---

18-19: Minor theming nit: prefer surface over background for screen containers.

Using colorScheme.surface (or a Surface composable) better aligns with Material 3 tonal elevation. Not required if you intentionally want the raw background color.

Apply:

-            .background(MaterialTheme.colorScheme.background),
+            .background(MaterialTheme.colorScheme.surface),

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (3)

70-73: Imports migration to core.presentation.component looks good.

The move from components → component aligns with the PR’s reorg and keeps call sites consistent.

---

78-78: TaskCard import from ui.component is consistent with new structure.

This keeps rendering concerns localized under ui.component. LGTM.

---

249-252: Correct: persist working order on drag stop.

Flushing reorderableTasks.mapIndexed { index to task } on drag end is the right moment to persist the visible order.

app/src/main/java/com/shub39/grit/core/presentation/component/InitialLoading.kt (1)

1-1: No residual “components” references found—singular “component” package confirmed

• Executed ripgrep scans across the codebase for any imports or package declarations of
  com.shub39.grit.core.presentation.components and found zero matches.
• All source files now correctly declare and import from
  com.shub39.grit.core.presentation.component.

The rename is consistent and safe to merge.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (2)

223-227: Reorder callback mutates a stale snapshot (tasks) instead of the working list (reorderableTasks)

This will clobber any in-progress reorders and can misplace items. The move operation should start from reorderableTasks.

Apply one of the following diffs:

Minimal fix (keep current add/remove semantics):

-    rememberReorderableLazyListState(lazyListState) { from, to ->
-        reorderableTasks = tasks.toMutableList().apply {
-            add(to.index, removeAt(from.index))
-        }
-    }
+    rememberReorderableLazyListState(lazyListState) { from, to ->
+        val mutable = reorderableTasks.toMutableList()
+        val moved = mutable.removeAt(from.index)
+        // If moving down, adjust target index after removal.
+        val target = if (to.index > from.index) to.index - 1 else to.index
+        mutable.add(target, moved)
+        reorderableTasks = mutable
+    }

Or, if you have/accept a small helper (safer and clearer):

+fun <T> MutableList<T>.move(from: Int, to: Int) {
+    if (from == to) return
+    val item = removeAt(from)
+    add(if (to > from) to - 1 else to, item)
+}
-    rememberReorderableLazyListState(lazyListState) { from, to ->
-        reorderableTasks = tasks.toMutableList().apply {
-            add(to.index, removeAt(from.index))
-        }
-    }
+    rememberReorderableLazyListState(lazyListState) { from, to ->
+        reorderableTasks = reorderableTasks.toMutableList().apply { move(from.index, to.index) }
+    }

---

268-281: Reinsertion on status toggle uses tasks and mismatched indices

When marking a task completed, the code rebuilds from tasks.toMutableList() and then removes at index from the current reorderableTasks context. That index may not correspond to the same element in tasks, leading to incorrect removals and lost reorders.

Apply this diff:

-                                                if (task.status) {
-                                                    reorderableTasks =
-                                                        tasks.toMutableList().apply {
-                                                            add(
-                                                                reorderableTasks.size - 1,
-                                                                removeAt(index)
-                                                            )
-                                                        }
+                                                if (task.status) {
+                                                    reorderableTasks = reorderableTasks.toMutableList().apply {
+                                                        add(size - 1, removeAt(index))
+                                                    }
                                                     onAction(
                                                         TaskPageAction.ReorderTasks(
                                                             reorderableTasks.mapIndexed { index, task -> index to task })
                                                     )
                                                 }

app/src/main/java/com/shub39/grit/core/presentation/component/PageFill.kt (1)

12-14: Nit: fix spacing and conventional type syntax in the signature

Minor polish for consistency with Kotlin/Compose style.

Apply this diff:

-@Composable
-fun  PageFill(
-    content: @Composable (BoxScope.() -> Unit)
-) {
+@Composable
+fun PageFill(
+    content: @Composable BoxScope.() -> Unit,
+) {

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (3)

220-224: Tighten the remember keys to avoid unnecessary resets of reorderableTasks

remember(state) will reset the working list on any state change (even unrelated to the current list), which can be jarring mid-edit. Scope it to the actual inputs.

Apply this diff:

-                var reorderableTasks by remember(state) { mutableStateOf(tasks) }
+                var reorderableTasks by remember(state.currentCategory, tasks) { mutableStateOf(tasks) }

If you want to persist local reorders until an explicit commit, consider:

var reorderableTasks by remember { mutableStateOf(tasks) }
LaunchedEffect(tasks) { reorderableTasks = tasks }

---

295-301: Prefer explicit size over padding-only Spacer

Spacer(modifier = Modifier.padding(60.dp)) can be confusing; a height-based spacer communicates intent.

Apply this diff:

-                        } else {
-                            Spacer(modifier = Modifier.padding(60.dp))
-                        }
+                        } else {
+                            Spacer(modifier = Modifier.size(60.dp))
+                        }

If you only need vertical spacing, use height(60.dp).

---

491-495: No-op KeyboardActions: remove or actually update the state

KeyboardActions(onAny = { newTitle.plus("\n") }) and newTask.plus("\n") do nothing because the result isn’t assigned. Also, with ImeAction.None, this likely never fires.

Apply this diff to remove the dead code:

-                keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTitle.plus("\n")
-                    }
-                ),
+                // No keyboardActions needed; multiline input handled by default.

and

-                keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTask.plus("\n")
-                    }
-                ),
+                // No keyboardActions needed; multiline input handled by default.

If your intent was to insert a newline on IME action, set an IME action and update the state: onDone = { newTitle += "\n" }.

Also applies to: 579-583

app/src/main/java/com/shub39/grit/tasks/presentation/TasksGraph.kt (1)

55-64: Consider consistent layering: wrap the Tasks graph with PageFill like Habits/Settings

HabitsGraph/SettingsGraph use PageFill { ... } at the graph level, while TasksGraph delegates PageFill to TaskList. Not a bug, but aligning the pattern keeps app scaffolding consistent and leaves sections free to focus on content.

Example:

-@Composable
-fun TasksGraph(
+@Composable
+fun TasksGraph(
     state: TaskPageState,
     onAction: (TaskPageAction) -> Unit
 ) {
-    val navController = rememberNavController()
+    val navController = rememberNavController()
+    PageFill {
       /* NavHost ... */
+    }
 }

If you do this, remove the PageFill wrapper from TaskList to avoid nesting Boxes.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

app/src/main/java/com/shub39/grit/core/presentation/component/PageFill.kt (1)

13-19: Good API upgrade: BoxScope receiver enables alignment and intrinsics within content

Changing content to @Composable BoxScope.() -> Unit is the right move. It unlocks Modifier.align(...) and other BoxScope APIs for callers (e.g., that FAB aligned to BottomEnd in TaskList). Using content = content with contentAlignment is also clean.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (2)

99-104: TopAppBar scroll behavior integration looks correct

Using TopAppBarDefaults.enterAlwaysScrollBehavior() and wiring it via Modifier.nestedScroll(scrollBehaviour.nestedScrollConnection) on the scrolling container is the right pattern for a collapsing bar.

---

307-337: FAB overlay via BoxScope alignment works well

Placing the FAB with Modifier.align(Alignment.BottomEnd) inside PageFill’s BoxScope is clean and keeps it above the scrolling content. Good use of AnimatedVisibility to gate it by currentCategory.

app/src/main/java/com/shub39/grit/tasks/presentation/TasksGraph.kt (2)

40-44: Rename to TasksGraph and route structure look good

The sealed routes + NavHost setup is tidy. Swapping in TaskList and navigating to EditCategories through typed routes is straightforward.

---

104-110: Preview: deterministic theme configuration is appreciated

Using isMaterialYou = false, seedColor = Color.Red, and TonalSpot produces stable previews. Matches recent theming guidance across the project.

app/src/main/java/com/shub39/grit/app/Grit.kt (4)

138-143: RTL-aware padding: nice upgrade

Switching to calculateStartPadding/calculateEndPadding ensures proper insets in RTL locales. Good attention to detail.

---

97-129: Bottom navigation simplification looks solid

Using NavigationBar without the previous rounded-clip keeps the layout simpler. Icons/labels are set correctly with alwaysShowLabel = false.

---

154-167: Graph adoption wired correctly

TasksGraph, SettingsGraph, and HabitsGraph are all invoked with the correct states and actions after the renames.

---

36-39: All old composable references have been removed

I performed a comprehensive code-wide search for any calls or imports of the legacy Tasks, Settings, and Habits composables and found no matches—there are no lingering references to the old names. This item can be closed.

gradle/libs.versions.toml (2)

2-5: LGTM: Dependency version updates look reasonable.

The version bumps appear to be incremental updates that should maintain compatibility. The changes include:

• AGP 8.11.1→8.12.1 (patch update)
• Kotlin 2.2.0→2.2.10 (patch update)
• Material3 1.4.0-alpha17→1.5.0-alpha02 (minor alpha update)
• Compose 1.8.3→1.9.0 (minor update)
• Other incremental updates to calendar, composeCharts, purchases, etc.

Also applies to: 11-14, 16-16, 18-18, 21-22

---

14-14: Reorderable bumped to 3.0.0 – LazyList API unchanged

I’ve reviewed the v3.0.0 release notes and confirmed that the only breaking changes concern the non-lazy containers (ReorderableColumn/ReorderableRow) and grid auto-scroll behavior—neither of which is used in our codebase (github.com). The official v3.0.0 README still shows the exact same rememberReorderableLazyListState + ReorderableItem pattern we use in both TaskList.kt and HabitsList.kt (github.com). No migration changes are needed for our LazyColumn-based reorderable lists.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (2)

252-265: Moving a completed task must operate on reorderableTasks, not tasks, and should append to the end clearly.

You’re rebuilding from tasks (original snapshot) which can drop prior reorders; this also mirrors a previously reported issue. Prefer appending via add(element) for clarity.

Apply this diff:

-                                                if (task.status) {
-                                                    reorderableTasks =
-                                                        tasks.toMutableList().apply {
-                                                            add(
-                                                                reorderableTasks.size - 1,
-                                                                removeAt(index)
-                                                            )
-                                                        }
+                                                if (updated.status) {
+                                                    reorderableTasks =
+                                                        reorderableTasks.toMutableList().apply {
+                                                            // move the toggled item to the end
+                                                            add(removeAt(index))
+                                                        }
                                                     onAction(
                                                         TaskPageAction.ReorderTasks(
                                                             reorderableTasks.mapIndexed { index, task -> index to task })
                                                     )
                                                 }

Additionally, to avoid in-place mutation on a list element (better state semantics in Compose), update the toggle to use an immutable copy:

-                                            if (!editState) {
-                                                task.status = !task.status
-
-                                                onAction(TaskPageAction.UpsertTask(task))
+                                            if (!editState) {
+                                                val updated = task.copy(status = !task.status)
+                                                onAction(TaskPageAction.UpsertTask(updated))

Note: This also requires the guard to check updated.status as shown above.

---

206-211: Reordering uses the immutable snapshot (tasks) instead of the working list (reorderableTasks).

This resets any in-progress order and can misplace items during drag. Use reorderableTasks as the source of truth inside the reorder callback.

Apply this diff:

-                val reorderableListState =
-                    rememberReorderableLazyListState(lazyListState) { from, to ->
-                        reorderableTasks = tasks.toMutableList().apply {
-                            add(to.index, removeAt(from.index))
-                        }
-                    }
+                val reorderableListState =
+                    rememberReorderableLazyListState(lazyListState) { from, to ->
+                        reorderableTasks = reorderableTasks.toMutableList().apply {
+                            add(to.index, removeAt(from.index))
+                        }
+                    }

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (8)

168-171: Category change commits the stale order (tasks) instead of the working order (reorderableTasks).

This can drop uncommitted reorders if the user switches categories mid-reorder. Either:

• Commit from reorderableTasks, or
• Omit the commit here and rely on the onDragStopped commit.

Given reorderableTasks is scoped inside AnimatedContent, the minimal safe fix is to remove the commit here.

Apply this diff to remove the stale commit:

-                        onAction(TaskPageAction.ReorderTasks(tasks.mapIndexed { index, task -> index to task }))
                         onAction(TaskPageAction.ChangeCategory(category))
                         editState = false

If you prefer to keep the commit on navigation, hoist reorderableTasks to a scope accessible here (e.g., remember keyed by category outside AnimatedContent) and commit from that instead.

---

246-251: Avoid in-place mutation of task.status; prefer immutable updates.

Directly mutating an element inside a remembered list can lead to subtle recomposition issues. Use copy and dispatch the new instance.

Apply this diff (coordinates with the later move logic fix):

-                                            if (!editState) {
-                                                task.status = !task.status
-
-                                                onAction(TaskPageAction.UpsertTask(task))
+                                            if (!editState) {
+                                                val updated = task.copy(status = !task.status)
+                                                onAction(TaskPageAction.UpsertTask(updated))

And replace subsequent references to task.status in this onClick block with updated.status.

---

100-111: Minor naming consistency: use scrollBehavior (US spelling) to match the API and reduce cognitive friction.

Purely stylistic, but aligns with TopAppBarDefaults.scrollBehavior property naming across Compose.

Apply this diff:

-    val scrollBehaviour = TopAppBarDefaults.enterAlwaysScrollBehavior()
+    val scrollBehavior = TopAppBarDefaults.enterAlwaysScrollBehavior()
@@
-        modifier = Modifier
-            .nestedScroll(scrollBehaviour.nestedScrollConnection)
+        modifier = Modifier
+            .nestedScroll(scrollBehavior.nestedScrollConnection)
@@
-            scrollBehavior = scrollBehaviour,
+            scrollBehavior = scrollBehavior,

---

204-206: Reinitializing reorderableTasks on any state change may be too aggressive.

remember(state) will reset the working list even for unrelated state changes (e.g., counters), potentially interrupting the UX. Consider scoping to category and/or the tasks list identity.

Apply this diff to reduce churn while still reacting to real task-list changes:

-                var reorderableTasks by remember(state) { mutableStateOf(tasks) }
+                var reorderableTasks by remember(category, tasks) { mutableStateOf(tasks) }

If the tasks list identity is stable on content mutations (new list instances on any change), the above will keep reorderableTasks in sync without resetting on unrelated state updates.

---

146-148: Enable condition can use the local tasks to avoid repeating a nullable map lookup.

Functionally equivalent but simpler and null-safe by construction.

Apply this diff:

-                            enabled = !state.tasks[state.currentCategory].isNullOrEmpty()
+                            enabled = tasks.isNotEmpty()

---

183-195: Replace hard-coded contentDescription strings with localized stringResources (and mark purely decorative icons as null).

This improves accessibility and i18n. For icons that convey no extra information beyond adjacent text, set contentDescription = null; otherwise use stringResource.

Apply these diffs:

-                    Icon(
-                        imageVector = Icons.Rounded.Add,
-                        contentDescription = "Add Category"
-                    )
+                    Icon(
+                        imageVector = Icons.Rounded.Add,
+                        contentDescription = stringResource(R.string.add_category)
+                    )

-                    Icon(
-                        imageVector = Icons.Rounded.Edit,
-                        contentDescription = "Edit Categories"
-                    )
+                    Icon(
+                        imageVector = Icons.Rounded.Edit,
+                        contentDescription = stringResource(R.string.edit_categories)
+                    )

-                                    Icon(
-                                        imageVector = Icons.Rounded.DragIndicator,
-                                        contentDescription = "Drag",
+                                    Icon(
+                                        imageVector = Icons.Rounded.DragIndicator,
+                                        contentDescription = stringResource(R.string.drag),
                                         modifier = Modifier.draggableHandle(

-            Icon(
-                imageVector = Icons.Rounded.Warning,
-                contentDescription = "Warning",
+            Icon(
+                imageVector = Icons.Rounded.Warning,
+                contentDescription = stringResource(R.string.warning),

-            Icon(
-                imageVector = Icons.Rounded.Add,
-                contentDescription = "Add"
+            Icon(
+                imageVector = Icons.Rounded.Add,
+                contentDescription = stringResource(R.string.add)

-            Icon(
-                imageVector = Icons.Rounded.Edit,
-                contentDescription = "Edit"
+            Icon(
+                imageVector = Icons.Rounded.Edit,
+                contentDescription = stringResource(R.string.edit)

If some of these string resources don’t exist yet (e.g., edit_categories, drag, warning), I can add them to strings.xml. Want me to open a follow-up PR?

Also applies to: 228-231, 330-333, 374-376, 443-446, 531-533

---

475-479: No-op keyboard action.

newTitle.plus("\n") doesn’t mutate state; the call result is discarded. Either remove keyboardActions or actually update state.

Apply one of:

Option A — remove it:

-                keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTitle.plus("\n")
-                    }
-                ),
+                // no keyboardActions needed; multi-line input already supports newline

Option B — mutate:

                 keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTitle.plus("\n")
-                    }
+                    onAny = { newTitle += "\n" }
                 ),

---

563-567: Same no-op keyboard action in Add Task sheet.

The .plus call does not change newTask.

Apply one of:

Option A — remove:

-                keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTask.plus("\n")
-                    }
-                ),
+                // no keyboardActions needed; multi-line input already supports newline

Option B — mutate:

                 keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTask.plus("\n")
-                    }
+                    onAny = { newTask += "\n" }
                 ),

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (1)

207-210: Reordering uses incorrect source list after initial drag.

The reordering operation uses tasks instead of reorderableTasks as the base list, which will reset any in-progress reorders and potentially misplace items when multiple drag operations occur.

                val reorderableListState =
                    rememberReorderableLazyListState(lazyListState) { from, to ->
-                       reorderableTasks = tasks.toMutableList().apply {
+                       reorderableTasks = reorderableTasks.toMutableList().apply {
                            add(to.index, removeAt(from.index))
                        }
                    }

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/EditCategories.kt (1)

100-120: Verify reorder toggle button visibility logic.

The reorder toggle button is only visible when there are 2+ categories but is disabled when the current category is empty. This creates a confusing UX where users see a disabled toggle with no clear reason. Consider either:

1. Hiding the toggle when the current category is empty, or
2. Showing a tooltip explaining why it's disabled

                AnimatedVisibility(
-                   visible = categories.size >= 2
+                   visible = categories.size >= 2 && !state.tasks[state.currentCategory].isNullOrEmpty()
                ) {
                    FilledTonalIconToggleButton(
                        checked = editState,
                        shapes = IconToggleButtonShapes(
                            shape = CircleShape,
                            checkedShape = MaterialTheme.shapes.small,
                            pressedShape = MaterialTheme.shapes.extraSmall,
                        ),
-                       onCheckedChange = { editState = it },
-                       enabled = !state.tasks[state.currentCategory].isNullOrEmpty()
+                       onCheckedChange = { editState = it }
                    ) {
                        Icon(
                            imageVector = Icons.Rounded.Reorder,
                            contentDescription = null
                        )
                    }
                }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/EditCategories.kt (1)

61-67: LGTM!

The function signature and return type correctly follow the new pattern with PageFill wrapper, aligning with the broader UI reorganization.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (1)

86-92: LGTM!

The function signature and PageFill wrapper integration align well with the new UI structure.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (2)

262-267: Reorder uses the working list, not the original snapshot. Good catch.

The move-on-complete path now starts from reorderableTasks.toMutableList(), preserving any in-progress reorders. This addresses the earlier review concern.

---

292-292: Spacer height fix looks good.

Spacer(modifier = Modifier.height(60.dp)) correctly reserves space to avoid FAB overlap.

app/src/main/java/com/shub39/grit/habits/presentation/ui/section/HabitsList.kt (1)

68-70: Missing import for draggableHandle (compile error persists).

Modifier.draggableHandle(...) is used at Line 167 but its extension import is still missing.

Apply this diff to fix the import:

 import sh.calvin.reorderable.ReorderableItem
 import sh.calvin.reorderable.rememberReorderableLazyListState
+import sh.calvin.reorderable.draggableHandle

app/src/main/java/com/shub39/grit/viewmodels/TasksViewModel.kt (3)

77-81: Batch category reorders atomically in the repo/DAO

Looping upsertCategory(...) for each mapping entry issues N separate writes and N flow emissions. Wrap the reorder in a single repository API executed in a DB transaction (e.g., Room @Transaction) to ensure atomicity and reduce intermediate UI states.

Proposed repository API:

suspend fun reorderCategories(mapping: List<Pair<Int, Category>>)

Then call repo.reorderCategories(action.mapping) here and drop the per-item loop.

---

151-161: Avoid forcing a non-empty key; prefer safe fallback and let observeTasks repair

Using it.tasks.keys.first() assumes the map is non-empty at that instant. While it currently runs before the repo deletion, using firstOrNull() is safer and aligns with the invariant fix above.

Apply this diff:

-                    currentCategory = it.tasks.keys.first()
+                    currentCategory = it.tasks.keys.firstOrNull()

---

61-69: UX nit: selecting the “first” category after Add may not be the newly added category

After adding, you set currentCategory to it.tasks.keys.firstOrNull(), which may not be the new category. If the intent is to focus the just-created category, set it explicitly to action.category (or its persisted copy with ID).

Potential tweak:

_state.update { it.copy(currentCategory = action.category /* or persisted copy */) }

Or let the invariant in observeTasks() handle selection if you prefer passive behavior.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (4)

212-221: Stabilize reorderableTasks initialization and syncing.

Using remember(category.id, state.tasks.values) can reset local reorders when unrelated categories change, and keys based on values are brittle. Initialize on category change and explicitly sync when that category’s list updates.

-                var reorderableTasks by remember(category.id, state.tasks.values) { mutableStateOf(
-                    state.tasks[category] ?: emptyList()
-                ) }
+                var reorderableTasks by remember(category.id) {
+                    mutableStateOf(state.tasks[category].orEmpty())
+                }
+                LaunchedEffect(state.tasks[category]) {
+                    // Sync local list when backing data for the current category changes.
+                    reorderableTasks = state.tasks[category].orEmpty()
+                }
                 val reorderableListState =
                     rememberReorderableLazyListState(lazyListState) { from, to ->
                         reorderableTasks = reorderableTasks.toMutableList().apply {
                             add(to.index, removeAt(from.index))
                         }
                     }

To verify no regressions, try: start a drag reorder without dropping, change another category’s tasks (e.g., complete a task there), then return—local reorder state for the active category should remain intact.

---

481-489: No-op KeyboardActions in edit sheet; switch to a meaningful IME action.

newTitle.plus("\n") doesn’t mutate newTitle, so onAny is a no-op. Recommend using ImeAction.Done and hiding the keyboard (or handling save).

-                keyboardOptions = KeyboardOptions.Default.copy(
-                    capitalization = KeyboardCapitalization.Sentences,
-                    imeAction = ImeAction.None
-                ),
-                keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTitle.plus("\n")
-                    }
-                ),
+                keyboardOptions = KeyboardOptions.Default.copy(
+                    capitalization = KeyboardCapitalization.Sentences,
+                    imeAction = ImeAction.Done
+                ),
+                keyboardActions = KeyboardActions(
+                    onDone = { keyboardController?.hide() }
+                ),

---

569-577: No-op KeyboardActions in add sheet; mirror the edit-sheet fix.

Same issue as above—newTask.plus("\n") is ineffective. Use a real IME action.

-                keyboardOptions = KeyboardOptions.Default.copy(
-                    capitalization = KeyboardCapitalization.Sentences,
-                    imeAction = ImeAction.None
-                ),
-                keyboardActions = KeyboardActions(
-                    onAny = {
-                        newTask.plus("\n")
-                    }
-                ),
+                keyboardOptions = KeyboardOptions.Default.copy(
+                    capitalization = KeyboardCapitalization.Sentences,
+                    imeAction = ImeAction.Done
+                ),
+                keyboardActions = KeyboardActions(
+                    onDone = { keyboardController?.hide() }
+                ),

---

102-108: Minor: smoother FAB visibility threshold.

Using only firstVisibleItemIndex can flicker at the top. Consider also checking firstVisibleItemScrollOffset.

-    val fabVisible by remember {
-        derivedStateOf {
-            lazyListState.firstVisibleItemIndex <= 0
-        }
-    }
+    val fabVisible by remember {
+        derivedStateOf {
+            lazyListState.firstVisibleItemIndex == 0 &&
+                lazyListState.firstVisibleItemScrollOffset < 10
+        }
+    }

app/src/main/java/com/shub39/grit/habits/presentation/ui/section/HabitsList.kt (6)

88-96: Prevent unnecessary resets of the local reordered list.

remember(state) will reset reorderableHabits whenever the state object identity changes (which can be frequent). Scope the memory key to the source of the list instead.

-    var reorderableHabits by remember(state) { mutableStateOf(habits) }
+    var reorderableHabits by remember(state.habitsWithStatuses) { mutableStateOf(habits) }

---

98-99: Use exitUntilCollapsed for a flexible top app bar (optional).

MediumFlexibleTopAppBar typically pairs better with TopAppBarDefaults.exitUntilCollapsedScrollBehavior(); enterAlways can feel jumpy in nested scroll scenarios.

-    val scrollBehavior = TopAppBarDefaults.enterAlwaysScrollBehavior()
+    val scrollBehavior = TopAppBarDefaults.exitUntilCollapsedScrollBehavior()

---

273-282: Align input thresholds with button enablement.

Title label/error use 20 chars as the limit; button uses < 20. This disables the Add button when length is exactly 20. Similarly, use <= 50 for description to match its label/error.

-                enabled = newHabitName.isNotBlank() && newHabitName.length < 20 && newHabitDescription.length < 50,
+                enabled = newHabitName.isNotBlank() && newHabitName.length <= 20 && newHabitDescription.length <= 50,

Also applies to: 377-381

---

404-405: Prefer explicit Spacer height over padding for vertical spacing.

Spacer(Modifier.padding(vertical = 4.dp)) results in 8.dp of vertical space and is less clear than a fixed height.

-                    Spacer(modifier = Modifier.padding(vertical = 4.dp))
+                    Spacer(modifier = Modifier.height(8.dp))

If you actually intended 4.dp, use Modifier.height(4.dp) instead.

---

336-357: Optional: Order day chips by the user’s configured starting day.

Currently uses DayOfWeek.entries, which always starts on Monday. Consider rotating the sequence so chips start at state.startingDay, matching the calendar UX.

Example (outside this block for clarity):

val orderedDays = generateSequence(state.startingDay) { it.plus(1).takeIf { next -> next != state.startingDay } }
    .toList()
orderedDays.forEach { dayOfWeek -> /* ToggleButton(...) */ }

---

360-372: Minor: Index for new item source of truth.

index = reorderableHabits.size will work, but consider using state.habitsWithStatuses.size to avoid any temporary divergence if local reorder state and VM state fall out of sync during recompositions.

-                        index = reorderableHabits.size,
+                        index = state.habitsWithStatuses.size,

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

app/src/main/java/com/shub39/grit/tasks/presentation/ui/section/TaskList.kt (1)

307-311: Confirm availability of animateFloatingActionButton().

Modifier.animateFloatingActionButton(...) is not part of stable Material3 APIs in older Compose versions. Ensure your dependency bump includes the artifact/version that provides this extension.

If your catalog pins Compose Material3, please verify the function exists by building locally. If unavailable, consider replacing with AnimatedVisibility + animate*AsState or AnimatedContent around the FAB.

app/src/main/java/com/shub39/grit/habits/presentation/ui/section/HabitsList.kt (1)

25-41: ✔️ Expressive Material3 API and Reorderable Dependency Verified

• The version catalog (gradle/libs.versions.toml) pins androidx.compose.material3:material3 to 1.5.0-alpha02, which includes the ExperimentalMaterial3ExpressiveApi and the MediumFlexibleTopAppBar, MediumFloatingActionButton, IconToggleButtonShapes, and ButtonShapes components.
• The sh.calvin.reorderable:reorderable library is declared in the same catalog, so no missing dependency issues.
• There is no usage or import of FlowRow in HabitsList.kt, so no additional @OptIn(ExperimentalLayoutApi::class) is required here.

All checks pass; no changes needed.