groove-dev 0.27.142 → 0.27.144

package/packages/gui/src/stores/slices/chat-slice.js

@@ -0,0 +1,227 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { api } from '../../lib/api';
+import { loadJSON, persistJSON } from '../helpers.js';
+
+const _modeChangePending = new Set();
+
+export const createChatSlice = (set, get) => ({
+  // ── Conversations (Chat view) ────────────────────────────
+  conversations: [],
+  activeConversationId: localStorage.getItem('groove:activeConversationId') || null,
+  conversationMessages: loadJSON('groove:conversationMessages'),
+  sendingMessage: false,
+  streamingConversationId: null,
+  conversationRoles: loadJSON('groove:conversationRoles'),
+  conversationReasoningEffort: loadJSON('groove:conversationReasoningEffort'),
+  conversationVerbosity: loadJSON('groove:conversationVerbosity'),
+
+  // ── Conversations (Chat view) ────────────────────────────
+
+  async fetchConversations() {
+    try {
+      const data = await api.get('/conversations');
+      set({ conversations: data.conversations || data || [] });
+    } catch { /* endpoint may not exist yet */ }
+  },
+
+  async createConversation(provider, model, mode = 'api') {
+    try {
+      const conv = await api.post('/conversations', { provider, model, mode });
+      set((s) => ({
+        conversations: [conv, ...s.conversations.filter((c) => c.id !== conv.id)],
+        activeConversationId: conv.id,
+      }));
+      localStorage.setItem('groove:activeConversationId', conv.id);
+      return conv;
+    } catch (err) {
+      get().addToast('error', 'Failed to create conversation', err.message);
+      throw err;
+    }
+  },
+
+  async setConversationMode(id, mode) {
+    if (_modeChangePending.has(id)) return;
+    _modeChangePending.add(id);
+    try {
+      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { mode });
+      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
+    } catch (err) {
+      get().addToast('error', 'Mode change failed', err.message);
+    } finally {
+      _modeChangePending.delete(id);
+    }
+  },
+
+  async setConversationModel(id, provider, model) {
+    try {
+      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { provider, model });
+      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
+    } catch (err) {
+      get().addToast('error', 'Model change failed', err.message);
+    }
+  },
+
+  async stopChatStreaming(conversationId) {
+    try {
+      await api.post(`/conversations/${encodeURIComponent(conversationId)}/stop`);
+      set({ sendingMessage: false, streamingConversationId: null });
+    } catch { /* ignore */ }
+  },
+
+  async deleteConversation(id) {
+    try {
+      await api.delete(`/conversations/${encodeURIComponent(id)}`);
+      set((s) => {
+        const conversations = s.conversations.filter((c) => c.id !== id);
+        const conversationMessages = { ...s.conversationMessages };
+        delete conversationMessages[id];
+        persistJSON('groove:conversationMessages', conversationMessages);
+        const activeConversationId = s.activeConversationId === id
+          ? (conversations[0]?.id || null)
+          : s.activeConversationId;
+        localStorage.setItem('groove:activeConversationId', activeConversationId || '');
+        const conversationRoles = { ...s.conversationRoles };
+        delete conversationRoles[id];
+        persistJSON('groove:conversationRoles', conversationRoles);
+        const conversationReasoningEffort = { ...s.conversationReasoningEffort };
+        delete conversationReasoningEffort[id];
+        persistJSON('groove:conversationReasoningEffort', conversationReasoningEffort);
+        const conversationVerbosity = { ...s.conversationVerbosity };
+        delete conversationVerbosity[id];
+        persistJSON('groove:conversationVerbosity', conversationVerbosity);
+        return { conversations, conversationMessages, conversationRoles, conversationReasoningEffort, conversationVerbosity, activeConversationId };
+      });
+    } catch (err) {
+      get().addToast('error', 'Delete failed', err.message);
+    }
+  },
+
+  async renameConversation(id, title) {
+    try {
+      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { title });
+      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
+    } catch (err) {
+      get().addToast('error', 'Rename failed', err.message);
+    }
+  },
+
+  async pinConversation(id, pinned) {
+    try {
+      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { pinned });
+      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
+    } catch (err) {
+      get().addToast('error', 'Pin failed', err.message);
+    }
+  },
+
+  setActiveConversation(id) {
+    set({ activeConversationId: id });
+    localStorage.setItem('groove:activeConversationId', id || '');
+  },
+
+  setConversationRole(id, role) {
+    set((s) => {
+      const roles = { ...s.conversationRoles };
+      if (role) {
+        roles[id] = role;
+      } else {
+        delete roles[id];
+      }
+      persistJSON('groove:conversationRoles', roles);
+      return { conversationRoles: roles };
+    });
+  },
+
+  setConversationReasoningEffort(id, effort) {
+    set((s) => {
+      const map = { ...s.conversationReasoningEffort };
+      map[id] = effort || 'medium';
+      persistJSON('groove:conversationReasoningEffort', map);
+      return { conversationReasoningEffort: map };
+    });
+  },
+
+  setConversationVerbosity(id, verbosity) {
+    set((s) => {
+      const map = { ...s.conversationVerbosity };
+      map[id] = verbosity || 'medium';
+      persistJSON('groove:conversationVerbosity', map);
+      return { conversationVerbosity: map };
+    });
+  },
+
+  async sendChatMessage(conversationId, message) {
+    const conv = get().conversations.find((c) => c.id === conversationId);
+    if (!conv) return;
+
+    // Add user message to local state immediately
+    set((s) => {
+      const msgs = { ...s.conversationMessages };
+      if (!msgs[conversationId]) msgs[conversationId] = [];
+      msgs[conversationId] = [...msgs[conversationId], { from: 'user', text: message, timestamp: Date.now() }];
+      persistJSON('groove:conversationMessages', msgs);
+      return { conversationMessages: msgs, sendingMessage: true, streamingConversationId: conversationId };
+    });
+
+    try {
+      const body = { message };
+      if (conv.mode === 'api' || !conv.mode) {
+        const history = get().conversationMessages[conversationId] || [];
+        body.history = history.slice(0, -1);
+
+        const role = get().conversationRoles?.[conversationId];
+        const rules = ['Never use emojis in your responses.', 'Be professional, concise, and direct.'];
+        if (role) rules.unshift(`You are a professional ${role}. Respond with deep expertise in that domain.`);
+        const systemCtx = rules.join(' ');
+        body.history = [
+          { from: 'user', text: `Instructions: ${systemCtx}` },
+          { from: 'assistant', text: 'Understood.' },
+          ...body.history,
+        ];
+      }
+      const effort = get().conversationReasoningEffort?.[conversationId] || 'medium';
+      const verbosity = get().conversationVerbosity?.[conversationId] || 'medium';
+      if (conv.provider === 'codex') {
+        body.reasoning_effort = effort;
+        body.verbosity = verbosity;
+      }
+      await api.post(`/conversations/${encodeURIComponent(conversationId)}/message`, body);
+    } catch (err) {
+      set((s) => {
+        const msgs = { ...s.conversationMessages };
+        if (!msgs[conversationId]) msgs[conversationId] = [];
+        msgs[conversationId] = [...msgs[conversationId], { from: 'system', text: `Failed: ${err.message}`, timestamp: Date.now() }];
+        persistJSON('groove:conversationMessages', msgs);
+        return { conversationMessages: msgs, sendingMessage: false, streamingConversationId: null };
+      });
+      get().addToast('error', 'Message failed', err.message);
+    }
+  },
+
+  async sendImageMessage(conversationId, prompt, { model, size, quality } = {}) {
+    const conv = get().conversations.find((c) => c.id === conversationId);
+    if (!conv) return;
+
+    set((s) => {
+      const msgs = { ...s.conversationMessages };
+      if (!msgs[conversationId]) msgs[conversationId] = [];
+      msgs[conversationId] = [...msgs[conversationId], { from: 'user', text: prompt, timestamp: Date.now() }];
+      persistJSON('groove:conversationMessages', msgs);
+      return { conversationMessages: msgs, sendingMessage: true, streamingConversationId: conversationId };
+    });
+
+    try {
+      await api.post(`/conversations/${encodeURIComponent(conversationId)}/generate-image`, { prompt, model, size, quality });
+    } catch (err) {
+      set((s) => {
+        const msgs = { ...s.conversationMessages };
+        if (!msgs[conversationId]) msgs[conversationId] = [];
+        msgs[conversationId] = [...msgs[conversationId], { from: 'system', text: `Image failed: ${err.message}`, timestamp: Date.now() }];
+        persistJSON('groove:conversationMessages', msgs);
+        return { conversationMessages: msgs, sendingMessage: false, streamingConversationId: null };
+      });
+      get().addToast('error', 'Image generation failed', err.message);
+    }
+  },
+});

package/packages/gui/src/stores/slices/editor-slice.js

@@ -0,0 +1,285 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { api } from '../../lib/api';
+
+export const createEditorSlice = (set, get) => ({
+  // ── Editor state ──────────────────────────────────────────
+  editorFiles: {},
+  editorActiveFile: null,
+  editorOpenTabs: [],
+  editorTreeCache: {},
+  editorChangedFiles: {},
+  editorRecentSaves: {},
+  editorSidebarWidth: Number(localStorage.getItem('groove:editorSidebarWidth')) || 240,
+  editorTheme: localStorage.getItem('groove:editorTheme') || 'vscodeDark',
+
+  // ── Editor (Cursor-style) ────────────────────────────────
+  editorSelectedAgent: null,
+  editorPendingSnippet: null,
+  editorViewMode: 'code',
+  editorAiPanelOpen: false,
+  editorAiPanelWidth: Number(localStorage.getItem('groove:editorAiPanelWidth')) || 360,
+  editorGitStatus: null,
+  editorGitBranch: null,
+  editorGitDiff: null,
+  editorQuickSearchOpen: false,
+
+  // ── Workspace Snapshots ────────────────────────────────────
+  workspaceSnapshots: {},
+
+  // ── Editor ────────────────────────────────────────────────
+
+  async openFile(path) {
+    if (get().editorFiles[path] || get().editorOpenTabs.includes(path)) {
+      set((s) => ({
+        editorActiveFile: path,
+        editorOpenTabs: s.editorOpenTabs.includes(path) ? s.editorOpenTabs : [...s.editorOpenTabs, path],
+      }));
+      return;
+    }
+    const ext = path.split('.').pop()?.toLowerCase();
+    const MEDIA = ['png','jpg','jpeg','gif','svg','webp','ico','bmp','avif','mp4','webm','mov','avi','mkv','ogv'];
+    if (MEDIA.includes(ext)) {
+      set((s) => ({ editorActiveFile: path, editorOpenTabs: [...s.editorOpenTabs, path] }));
+      return;
+    }
+    try {
+      const data = await api.get(`/files/read?path=${encodeURIComponent(path)}`);
+      if (data.binary) { get().addToast('warning', 'Binary file — cannot open'); return; }
+      set((s) => ({
+        editorFiles: { ...s.editorFiles, [path]: { content: data.content, originalContent: data.content, language: data.language, loadedAt: Date.now() } },
+        editorActiveFile: path,
+        editorOpenTabs: s.editorOpenTabs.includes(path) ? s.editorOpenTabs : [...s.editorOpenTabs, path],
+      }));
+      const ws = get().ws;
+      if (ws?.readyState === 1) ws.send(JSON.stringify({ type: 'editor:watch', path }));
+    } catch (err) {
+      get().addToast('error', 'Failed to open file', err.message);
+    }
+  },
+
+  closeFile(path) {
+    set((s) => {
+      const tabs = s.editorOpenTabs.filter((t) => t !== path);
+      const files = { ...s.editorFiles };
+      delete files[path];
+      const changed = { ...s.editorChangedFiles };
+      delete changed[path];
+      let active = s.editorActiveFile;
+      if (active === path) {
+        const idx = s.editorOpenTabs.indexOf(path);
+        active = tabs[Math.min(idx, tabs.length - 1)] || null;
+      }
+      return { editorOpenTabs: tabs, editorFiles: files, editorChangedFiles: changed, editorActiveFile: active };
+    });
+    const ws = get().ws;
+    if (ws?.readyState === 1) ws.send(JSON.stringify({ type: 'editor:unwatch', path }));
+  },
+
+  setActiveFile(path) { set({ editorActiveFile: path }); },
+
+  setEditorSidebarWidth(width) {
+    set({ editorSidebarWidth: width });
+    localStorage.setItem('groove:editorSidebarWidth', String(width));
+  },
+  setEditorTheme(theme) {
+    set({ editorTheme: theme });
+    localStorage.setItem('groove:editorTheme', theme);
+  },
+
+  updateFileContent(path, content) {
+    set((s) => ({ editorFiles: { ...s.editorFiles, [path]: { ...s.editorFiles[path], content } } }));
+  },
+
+  async saveFile(path) {
+    const file = get().editorFiles[path];
+    if (!file) return;
+    try {
+      await api.post('/files/write', { path, content: file.content });
+      set((s) => ({
+        editorFiles: { ...s.editorFiles, [path]: { ...s.editorFiles[path], originalContent: file.content } },
+        editorChangedFiles: (() => { const c = { ...s.editorChangedFiles }; delete c[path]; return c; })(),
+        editorRecentSaves: { ...s.editorRecentSaves, [path]: Date.now() },
+      }));
+      get().addToast('success', 'File saved');
+    } catch (err) {
+      get().addToast('error', 'Save failed', err.message);
+    }
+  },
+
+  async reloadFile(path) {
+    try {
+      const data = await api.get(`/files/read?path=${encodeURIComponent(path)}`);
+      if (data.binary) return;
+      set((s) => ({
+        editorFiles: { ...s.editorFiles, [path]: { content: data.content, originalContent: data.content, language: data.language, loadedAt: Date.now() } },
+        editorChangedFiles: (() => { const c = { ...s.editorChangedFiles }; delete c[path]; return c; })(),
+      }));
+    } catch { /* ignore */ }
+  },
+
+  dismissFileChange(path) {
+    set((s) => { const c = { ...s.editorChangedFiles }; delete c[path]; return { editorChangedFiles: c }; });
+  },
+
+  async fetchTreeDir(dirPath) {
+    try {
+      const data = await api.get(`/files/tree?path=${encodeURIComponent(dirPath)}`);
+      set((s) => ({ editorTreeCache: { ...s.editorTreeCache, [dirPath]: data.entries || [] } }));
+      const ws = get().ws;
+      if (ws?.readyState === 1) ws.send(JSON.stringify({ type: 'editor:watchdir', path: dirPath }));
+    } catch (err) {
+      console.error('[file-tree] fetchTreeDir failed for', dirPath, err.message);
+      set((s) => ({ editorTreeCache: { ...s.editorTreeCache, [dirPath]: [] } }));
+    }
+  },
+
+  async createFile(relPath) {
+    try {
+      await api.post('/files/create', { path: relPath });
+      const parent = relPath.includes('/') ? relPath.split('/').slice(0, -1).join('/') : '';
+      await get().fetchTreeDir(parent);
+      get().addToast('success', 'File created');
+      return true;
+    } catch (err) {
+      get().addToast('error', 'Create failed', err.message);
+      return false;
+    }
+  },
+
+  async createDir(relPath) {
+    try {
+      await api.post('/files/mkdir', { path: relPath });
+      const parent = relPath.includes('/') ? relPath.split('/').slice(0, -1).join('/') : '';
+      await get().fetchTreeDir(parent);
+      get().addToast('success', 'Folder created');
+      return true;
+    } catch (err) {
+      get().addToast('error', 'Create failed', err.message);
+      return false;
+    }
+  },
+
+  async deleteFile(relPath) {
+    try {
+      await api.delete(`/files/delete?path=${encodeURIComponent(relPath)}`);
+      if (get().editorOpenTabs.includes(relPath)) get().closeFile(relPath);
+      const parent = relPath.includes('/') ? relPath.split('/').slice(0, -1).join('/') : '';
+      await get().fetchTreeDir(parent);
+      set((s) => { const cache = { ...s.editorTreeCache }; delete cache[relPath]; return { editorTreeCache: cache }; });
+      get().addToast('success', 'Deleted');
+      return true;
+    } catch (err) {
+      get().addToast('error', 'Delete failed', err.message);
+      return false;
+    }
+  },
+
+  async renameFile(oldPath, newPath) {
+    try {
+      await api.post('/files/rename', { oldPath, newPath });
+      set((s) => {
+        const tabs = s.editorOpenTabs.map((t) => t === oldPath ? newPath : t);
+        const files = { ...s.editorFiles };
+        if (files[oldPath]) { files[newPath] = files[oldPath]; delete files[oldPath]; }
+        const active = s.editorActiveFile === oldPath ? newPath : s.editorActiveFile;
+        return { editorOpenTabs: tabs, editorFiles: files, editorActiveFile: active };
+      });
+      const oldParent = oldPath.includes('/') ? oldPath.split('/').slice(0, -1).join('/') : '';
+      const newParent = newPath.includes('/') ? newPath.split('/').slice(0, -1).join('/') : '';
+      await get().fetchTreeDir(oldParent);
+      if (newParent !== oldParent) await get().fetchTreeDir(newParent);
+      get().addToast('success', 'Renamed');
+      return true;
+    } catch (err) {
+      get().addToast('error', 'Rename failed', err.message);
+      return false;
+    }
+  },
+
+  captureSnapshot(path, content) {
+    set((s) => {
+      if (s.workspaceSnapshots[path]) return s;
+      const next = { ...s.workspaceSnapshots, [path]: content };
+      const keys = Object.keys(next);
+      if (keys.length > 200) {
+        delete next[keys[0]];
+      }
+      return { workspaceSnapshots: next };
+    });
+  },
+
+  // ── Editor (Cursor-style) ──────────────────────────────────
+
+  setEditorAgent(id) {
+    set({ editorSelectedAgent: id });
+  },
+
+  setEditorViewMode(mode) {
+    set({ editorViewMode: mode });
+  },
+
+  toggleAiPanel() {
+    set((s) => {
+      const open = !s.editorAiPanelOpen;
+      return { editorAiPanelOpen: open };
+    });
+  },
+
+  setEditorAiPanelWidth(width) {
+    set({ editorAiPanelWidth: width });
+    localStorage.setItem('groove:editorAiPanelWidth', String(width));
+  },
+
+  setEditorQuickSearchOpen(open) {
+    set({ editorQuickSearchOpen: open });
+  },
+
+  attachSnippet(snippet) {
+    set({ editorPendingSnippet: snippet });
+    if (!get().editorAiPanelOpen) {
+      set({ editorAiPanelOpen: true });
+    }
+  },
+
+  clearSnippet() {
+    set({ editorPendingSnippet: null });
+  },
+
+  async sendCodeToAgent(agentId, instruction, filePath, lineStart, lineEnd, selectedCode) {
+    if (!agentId) return;
+    get().attachSnippet({
+      type: 'code',
+      instruction,
+      filePath,
+      lineStart,
+      lineEnd,
+      code: selectedCode,
+    });
+  },
+
+  async fetchGitStatus() {
+    try {
+      const data = await api.get('/files/git-status');
+      set({ editorGitStatus: data });
+      return data;
+    } catch { return null; }
+  },
+
+  async fetchGitBranch() {
+    try {
+      const data = await api.get('/files/git-branch');
+      set({ editorGitBranch: data });
+      return data;
+    } catch { return null; }
+  },
+
+  async fetchGitDiff(path) {
+    try {
+      const url = path ? `/files/git-diff?path=${encodeURIComponent(path)}` : '/files/git-diff';
+      const data = await api.get(url);
+      set({ editorGitDiff: data });
+      return data;
+    } catch { return null; }
+  },
+});