kasy-cli 1.2.1

package/lib/scaffold/backends/supabase/patch/lib/features/feedbacks/ui/component/add_feature_form.dart

@@ -0,0 +1,199 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:go_router/go_router.dart';
+import 'package:kasy_kit/components/components.dart';
+import 'package:kasy_kit/core/theme/theme.dart';
+import 'package:kasy_kit/core/widgets/kasy_scroll_behavior.dart';
+import 'package:kasy_kit/features/feedbacks/providers/feedback_page_notifier.dart';
+import 'package:kasy_kit/i18n/translations.g.dart';
+
+Future<void> showAddFeatureBottomSheet(BuildContext context) {
+  return showModalBottomSheet<bool?>(
+    context: context,
+    isScrollControlled: true,
+    builder: (context) => const FractionallySizedBox(
+      heightFactor: .8,
+      child: AddFeatureComponent(),
+    ),
+  ).then((res) {
+    if (!context.mounted) return;
+    final translations = Translations.of(context).feature_requests.add_feature;
+    if (res == true) {
+      showSuccessToast(
+        context: context,
+        title: translations.toast_success.title,
+        text: translations.toast_success.description,
+      );
+    }
+  });
+}
+
+class AddFeatureComponent extends ConsumerStatefulWidget {
+  const AddFeatureComponent({super.key});
+
+  @override
+  ConsumerState<ConsumerStatefulWidget> createState() =>
+      _AddFeatureComponentState();
+}
+
+class _AddFeatureComponentState extends ConsumerState<AddFeatureComponent> {
+  String title = '';
+  String description = '';
+  bool locked = false;
+
+  final titleFocusNode = FocusNode();
+  final textFocusNode = FocusNode();
+
+  bool get _titleFilled => title.trim().isNotEmpty;
+  bool get _descriptionValid => description.length >= 40;
+  bool get canSubmit => _titleFilled && _descriptionValid && !locked;
+
+  void _onSubmitAttempt() {
+    final tr = Translations.of(context).feature_requests.add_feature;
+    if (!_titleFilled || description.trim().isEmpty) {
+      ref.read(toastProvider).error(
+            title: tr.error_title,
+            text: tr.error_required,
+          );
+      return;
+    }
+    if (!_descriptionValid) {
+      ref.read(toastProvider).error(
+            title: tr.error_title,
+            text: tr.error_too_short,
+          );
+      return;
+    }
+  }
+
+  void _submit() {
+    if (locked) return;
+    FocusScope.of(context).unfocus();
+    locked = true;
+    final tr = Translations.of(context).feature_requests.add_feature;
+    ref
+        .read(feedbackPageProvider.notifier)
+        .createFeatureSuggestion(
+          title: title,
+          description: description,
+        )
+        .then(
+          (_) {
+            locked = false;
+            if (!mounted) return;
+            context.pop(true);
+          },
+          onError: (_) {
+            locked = false;
+            ref.read(toastProvider).error(
+                  title: tr.error_title,
+                  text: tr.error_sending,
+                );
+          },
+        );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final translations = Translations.of(context).feature_requests.add_feature;
+
+    final Widget submitButton = KasyButton(
+      label: translations.save_button,
+      expand: true,
+      onPressed: canSubmit ? _submit : null,
+    );
+
+    return Scaffold(
+      body: Stack(
+        fit: StackFit.expand,
+        children: [
+          Positioned.fill(
+            child: ScrollConfiguration(
+              behavior: const KasyKitScrollBehavior(),
+              child: CustomScrollView(
+                slivers: kasyOverlayPaddedSlivers(
+                  context,
+                  contentPadding: EdgeInsets.fromLTRB(
+                    KasySpacing.pageHorizontalGutter,
+                    KasySpacing.belowChromeContentGap,
+                    KasySpacing.pageHorizontalGutter,
+                    MediaQuery.paddingOf(context).bottom + KasySpacing.xxxl,
+                  ),
+                  slivers: [
+                    SliverToBoxAdapter(
+                      child: Column(
+                          crossAxisAlignment: CrossAxisAlignment.stretch,
+                          children: [
+                            const SizedBox(height: KasySpacing.md),
+                            Text(
+                              translations.description,
+                              style: context.textTheme.bodyMedium?.copyWith(
+                                color: context.colors.muted,
+                                height: 1.5,
+                              ),
+                            ),
+                            const SizedBox(height: KasySpacing.xl),
+                            KasyTextField(
+                              label: translations.title_label,
+                              hint: translations.title_hint,
+                              showRequiredIndicator: true,
+                              variant: KasyTextFieldVariant.secondary,
+                              onChanged: (value) =>
+                                  setState(() => title = value),
+                              focusNode: titleFocusNode,
+                              textInputAction: TextInputAction.next,
+                              onSubmitted: (_) {
+                                titleFocusNode.unfocus();
+                                textFocusNode.requestFocus();
+                              },
+                              maxLength: 40,
+                            ),
+                            const SizedBox(height: KasySpacing.md),
+                            KasyTextField(
+                              label: translations.description_label,
+                              hint: translations.description_hint,
+                              showRequiredIndicator: true,
+                              variant: KasyTextFieldVariant.secondary,
+                              minLines: 6,
+                              maxLines: 6,
+                              onChanged: (value) =>
+                                  setState(() => description = value),
+                              textInputAction: TextInputAction.done,
+                              onSubmitted: (_) => textFocusNode.unfocus(),
+                              maxLength: 1000,
+                              focusNode: textFocusNode,
+                            ),
+                            const SizedBox(height: KasySpacing.xl),
+                          ],
+                        ),
+                      ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+          Positioned(
+            top: 0,
+            left: 0,
+            right: 0,
+            child: KasyAppBar(
+              title: translations.title,
+              onBack: () => context.pop(),
+            ),
+          ),
+          Positioned(
+            left: KasySpacing.pageHorizontalGutter,
+            right: KasySpacing.pageHorizontalGutter,
+            bottom: MediaQuery.paddingOf(context).bottom + KasySpacing.md,
+            child: canSubmit
+                ? submitButton
+                : GestureDetector(
+                    onTap: _onSubmitAttempt,
+                    child: submitButton,
+                  ),
+          ),
+        ],
+      ),
+    );
+  }
+}

package/lib/scaffold/backends/supabase/patch/lib/features/llm_chat/api/llm_chat_api.dart

@@ -0,0 +1,47 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:logger/logger.dart';
+import 'package:kasy_kit/features/llm_chat/api/llm_chat_message_entity.dart';
+import 'package:supabase_flutter/supabase_flutter.dart';
+
+final llmChatApiProvider = Provider<LlmChatApi>(
+  (ref) => LlmChatApi(client: Supabase.instance.client),
+);
+
+const _kTable = 'llm_messages';
+
+class LlmChatApi {
+  final SupabaseClient _client;
+  final Logger _logger = Logger();
+
+  LlmChatApi({required SupabaseClient client}) : _client = client;
+
+  /// Returns all messages for a user, ordered by creation time (oldest first).
+  Future<List<LlmChatMessageEntity>> loadMessages(String userId) async {
+    final rows = await _client
+        .from(_kTable)
+        .select()
+        .eq('user_id', userId)
+        .order('created_at', ascending: true);
+    return rows.map(LlmChatMessageEntity.fromJson).toList();
+  }
+
+  /// Persists a single message to Supabase.
+  Future<void> saveMessage(
+    String userId,
+    LlmChatMessageEntity message,
+  ) async {
+    try {
+      await _client.from(_kTable).insert({
+        'user_id': userId,
+        ...message.toJson(),
+      });
+    } catch (e) {
+      _logger.e('Failed to persist LLM message: $e');
+    }
+  }
+
+  /// Deletes all stored messages for a user (clear history).
+  Future<void> clearHistory(String userId) async {
+    await _client.from(_kTable).delete().eq('user_id', userId);
+  }
+}

package/lib/scaffold/backends/supabase/patch/lib/features/llm_chat/api/llm_chat_message_entity.dart

@@ -0,0 +1,30 @@
+/// Supabase row mapping for a single LLM chat message.
+/// Table: public.llm_messages
+class LlmChatMessageEntity {
+  final String? id;
+  final String role; // 'user' or 'assistant'
+  final String content;
+  final DateTime createdAt;
+
+  const LlmChatMessageEntity({
+    this.id,
+    required this.role,
+    required this.content,
+    required this.createdAt,
+  });
+
+  factory LlmChatMessageEntity.fromJson(Map<String, dynamic> json) {
+    return LlmChatMessageEntity(
+      id: json['id'] as String?,
+      role: json['role'] as String,
+      content: json['content'] as String,
+      createdAt: DateTime.parse(json['created_at'] as String),
+    );
+  }
+
+  Map<String, dynamic> toJson() => {
+        'role': role,
+        'content': content,
+        'created_at': createdAt.toUtc().toIso8601String(),
+      };
+}

package/lib/scaffold/backends/supabase/patch/lib/features/llm_chat/providers/llm_chat_notifier.dart

@@ -0,0 +1,266 @@
+import 'dart:convert';
+
+import 'package:dio/dio.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/config/app_env.dart';
+import 'package:kasy_kit/core/states/translations.dart';
+import 'package:kasy_kit/core/states/user_state_notifier.dart';
+import 'package:kasy_kit/features/llm_chat/api/llm_chat_api.dart';
+import 'package:kasy_kit/features/llm_chat/api/llm_chat_message_entity.dart';
+import 'package:logger/logger.dart';
+import 'package:supabase_flutter/supabase_flutter.dart';
+
+const int _kMaxContextMessages = 20;
+
+class ChatMessage {
+  final String role;
+  final String content;
+
+  const ChatMessage({required this.role, required this.content});
+
+  factory ChatMessage.user(String content) =>
+      ChatMessage(role: 'user', content: content);
+
+  factory ChatMessage.assistant(String content) =>
+      ChatMessage(role: 'assistant', content: content);
+
+  factory ChatMessage.fromEntity(LlmChatMessageEntity entity) =>
+      ChatMessage(role: entity.role, content: entity.content);
+
+  LlmChatMessageEntity toEntity() => LlmChatMessageEntity(
+    role: role,
+    content: content,
+    createdAt: DateTime.now(),
+  );
+}
+
+class LlmChatState {
+  final List<ChatMessage> messages;
+  final bool isReplying;
+  final bool streamingStarted;
+
+  const LlmChatState({
+    required this.messages,
+    this.isReplying = false,
+    this.streamingStarted = false,
+  });
+
+  LlmChatState copyWith({
+    List<ChatMessage>? messages,
+    bool? isReplying,
+    bool? streamingStarted,
+  }) {
+    return LlmChatState(
+      messages: messages ?? this.messages,
+      isReplying: isReplying ?? this.isReplying,
+      streamingStarted: streamingStarted ?? this.streamingStarted,
+    );
+  }
+}
+
+final llmChatNotifierProvider =
+    AsyncNotifierProvider<LlmChatNotifier, LlmChatState>(LlmChatNotifier.new);
+
+class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
+  final Logger _logger = Logger();
+
+  @override
+  Future<LlmChatState> build() async {
+    final userId = ref.read(userStateNotifierProvider).user.idOrNull;
+    if (userId == null) return const LlmChatState(messages: []);
+
+    try {
+      final entities = await ref.read(llmChatApiProvider).loadMessages(userId);
+      return LlmChatState(
+        messages: entities.map(ChatMessage.fromEntity).toList(),
+      );
+    } catch (e) {
+      _logger.e('Failed to load LLM chat history: $e');
+      return const LlmChatState(messages: []);
+    }
+  }
+
+  Future<void> sendMessage(String prompt) async {
+    final current = switch (state) {
+      AsyncData(:final value) => value,
+      _ => null,
+    };
+    if (current == null || current.isReplying) return;
+
+    final userMsg = ChatMessage.user(prompt);
+    state = AsyncData(
+      current.copyWith(
+        messages: [...current.messages, userMsg],
+        isReplying: true,
+        streamingStarted: false,
+      ),
+    );
+
+    _persistMessage(userMsg);
+
+    final allMessages = (state as AsyncData<LlmChatState>).value.messages;
+    final history = allMessages.length > _kMaxContextMessages
+        ? allMessages.sublist(allMessages.length - _kMaxContextMessages)
+        : allMessages;
+    await _requestReplyStream(history);
+  }
+
+  Future<void> _requestReplyStream(List<ChatMessage> history) async {
+    final t = ref.read(translationsProvider).llm_chat;
+    final String llmChatEndpoint = AppEnv.llmChatEndpoint;
+
+    if (llmChatEndpoint.isEmpty) {
+      _finalizeAssistantMessage(t.error_not_configured);
+      return;
+    }
+
+    final accessToken =
+        Supabase.instance.client.auth.currentSession?.accessToken;
+    if (accessToken == null) {
+      _finalizeAssistantMessage(t.error_not_configured);
+      return;
+    }
+
+    final dio = Dio(
+      BaseOptions(
+        headers: {
+          'Authorization': 'Bearer $accessToken',
+          'Content-Type': 'application/json',
+        },
+      ),
+    );
+
+    try {
+      final response = await dio.post<ResponseBody>(
+        llmChatEndpoint,
+        data: {
+          'message': history.last.content,
+          'history': history
+              .map((e) => {'role': e.role, 'content': e.content})
+              .toList(growable: false),
+        },
+        options: Options(responseType: ResponseType.stream),
+      );
+
+      final lineBuffer = StringBuffer();
+      final contentBuffer = StringBuffer();
+
+      await for (final chunk in response.data!.stream) {
+        final text = utf8.decode(chunk, allowMalformed: true);
+        lineBuffer.write(text);
+
+        final raw = lineBuffer.toString();
+        final lastNewline = raw.lastIndexOf('\n');
+        if (lastNewline == -1) continue;
+
+        final completeSection = raw.substring(0, lastNewline + 1);
+        lineBuffer.clear();
+        if (lastNewline < raw.length - 1) {
+          lineBuffer.write(raw.substring(lastNewline + 1));
+        }
+
+        for (final line in completeSection.split('\n')) {
+          final delta = _extractSSEDelta(line.trimRight());
+          if (delta.isEmpty) continue;
+
+          contentBuffer.write(delta);
+          _appendStreamingChunk(contentBuffer.toString());
+        }
+      }
+
+      final fullContent = contentBuffer.toString();
+      if (fullContent.isNotEmpty) {
+        _persistMessage(ChatMessage.assistant(fullContent));
+      } else {
+        _finalizeAssistantMessage(t.error_no_reply);
+        return;
+      }
+
+      final latest = switch (state) {
+        AsyncData(:final value) => value,
+        _ => null,
+      };
+      if (latest != null) {
+        state = AsyncData(
+          latest.copyWith(isReplying: false, streamingStarted: false),
+        );
+      }
+    } catch (error) {
+      _logger.e('LLM chat stream failed: $error');
+      _finalizeAssistantMessage(t.error_network);
+    }
+  }
+
+  void _appendStreamingChunk(String partialContent) {
+    final current = switch (state) {
+      AsyncData(:final value) => value,
+      _ => null,
+    };
+    if (current == null) return;
+
+    final msgs = current.messages;
+    final newMsgs = current.streamingStarted
+        ? [
+            ...msgs.sublist(0, msgs.length - 1),
+            ChatMessage.assistant(partialContent),
+          ]
+        : [...msgs, ChatMessage.assistant(partialContent)];
+
+    state = AsyncData(
+      LlmChatState(messages: newMsgs, isReplying: true, streamingStarted: true),
+    );
+  }
+
+  void _finalizeAssistantMessage(String content) {
+    final current = switch (state) {
+      AsyncData(:final value) => value,
+      _ => const LlmChatState(messages: []),
+    };
+    final msgs = current.messages;
+    final newMsgs = current.streamingStarted
+        ? [...msgs.sublist(0, msgs.length - 1), ChatMessage.assistant(content)]
+        : [...msgs, ChatMessage.assistant(content)];
+    state = AsyncData(LlmChatState(messages: newMsgs));
+  }
+
+  String _extractSSEDelta(String line) {
+    if (!line.startsWith('data: ')) return '';
+    final payload = line.substring(6);
+    if (payload == '[DONE]') return '';
+    try {
+      final json = jsonDecode(payload) as Map<String, dynamic>;
+
+      final choices = json['choices'] as List?;
+      if (choices != null && choices.isNotEmpty) {
+        final delta =
+            (choices.first as Map<String, dynamic>)['delta']
+                as Map<String, dynamic>?;
+        return (delta?['content'] as String?) ?? '';
+      }
+
+      final candidates = json['candidates'] as List?;
+      if (candidates != null && candidates.isNotEmpty) {
+        final content =
+            (candidates.first as Map<String, dynamic>)['content']
+                as Map<String, dynamic>?;
+        final parts = content?['parts'] as List?;
+        if (parts != null && parts.isNotEmpty) {
+          return ((parts.first as Map<String, dynamic>)['text'] as String?) ??
+              '';
+        }
+      }
+    } catch (_) {}
+    return '';
+  }
+
+  void _persistMessage(ChatMessage message) {
+    final userId = ref.read(userStateNotifierProvider).user.idOrNull;
+    if (userId == null) return;
+    ref
+        .read(llmChatApiProvider)
+        .saveMessage(userId, message.toEntity())
+        .catchError((e) {
+          _logger.e('Failed to persist message: $e');
+        });
+  }
+}