groove-dev 0.27.139 → 0.27.141

package/node_modules/@groove-dev/gui/src/stores/groove.js

@@ -115,6 +115,12 @@ export const useGrooveStore = create((set, get) => ({
   conversationReasoningEffort: loadJSON('groove:conversationReasoningEffort'),
   conversationVerbosity: loadJSON('groove:conversationVerbosity'),
 
+  // ── Keeper (tagged memory) ─────────────────────────────────
+  keeperItems: [],
+  keeperTree: [],
+  keeperEditing: null,  // { tag, content, isNew, readOnly } — drives the editor modal
+  keeperInstructOpen: false,
+
   // ── Approvals ─────────────────────────────────────────────
   pendingApprovals: [],
   resolvedApprovals: [],
@@ -207,6 +213,7 @@ export const useGrooveStore = create((set, get) => ({
 
   // ── Editor (Cursor-style) ────────────────────────────────
   editorSelectedAgent: null,
+  editorPendingSnippet: null,
   editorViewMode: 'code',
   editorAiPanelOpen: false,
   editorAiPanelWidth: Number(localStorage.getItem('groove:editorAiPanelWidth')) || 360,
@@ -659,6 +666,7 @@ export const useGrooveStore = create((set, get) => ({
         case 'lab:runtime:added':
         case 'lab:runtime:updated':
         case 'lab:runtime:removed':
+        case 'llama:server:stopped':
           get().fetchLabRuntimes();
           break;
 
@@ -1212,6 +1220,12 @@ export const useGrooveStore = create((set, get) => ({
           set((s) => ({ networkBenchmarks: [...s.networkBenchmarks, sd].slice(-100) }));
           break;
         }
+
+        case 'keeper:saved':
+        case 'keeper:updated':
+        case 'keeper:deleted':
+          get().fetchKeeperItems();
+          break;
       }
     };
 
@@ -1230,6 +1244,189 @@ export const useGrooveStore = create((set, get) => ({
 
   setActiveView(view) { set({ activeView: view }); },
 
+  // ── Keeper (tagged memory) ────────────────────────────────
+
+  async fetchKeeperItems() {
+    try {
+      const data = await api.get('/keeper');
+      const treeData = await api.get('/keeper/tree');
+      set({ keeperItems: data.items || [], keeperTree: treeData.tree || [] });
+    } catch { /* ignore */ }
+  },
+
+  async saveKeeperItem(tag, content) {
+    try {
+      const item = await api.post('/keeper', { tag, content });
+      get().fetchKeeperItems();
+      get().addToast('success', `Saved #${item.tag}`);
+      return item;
+    } catch (err) {
+      get().addToast('error', 'Failed to save memory', err.message);
+      throw err;
+    }
+  },
+
+  async appendKeeperItem(tag, content) {
+    try {
+      const item = await api.post('/keeper/append', { tag, content });
+      get().fetchKeeperItems();
+      get().addToast('success', `Appended to #${item.tag}`);
+      return item;
+    } catch (err) {
+      get().addToast('error', 'Failed to append', err.message);
+      throw err;
+    }
+  },
+
+  async updateKeeperItem(tag, content) {
+    try {
+      const item = await api.patch(`/keeper/${tag}`, { content });
+      get().fetchKeeperItems();
+      get().addToast('success', `Updated #${item.tag}`);
+      return item;
+    } catch (err) {
+      get().addToast('error', 'Failed to update memory', err.message);
+      throw err;
+    }
+  },
+
+  async deleteKeeperItem(tag) {
+    try {
+      await api.delete(`/keeper/${tag}`);
+      get().fetchKeeperItems();
+      get().addToast('success', `Deleted #${tag}`);
+    } catch (err) {
+      get().addToast('error', 'Failed to delete memory', err.message);
+    }
+  },
+
+  async getKeeperItem(tag) {
+    try {
+      return await api.get(`/keeper/${tag}`);
+    } catch {
+      return null;
+    }
+  },
+
+  async searchKeeper(query) {
+    try {
+      const data = await api.get(`/keeper/search?q=${encodeURIComponent(query)}`);
+      return data.results || [];
+    } catch {
+      return [];
+    }
+  },
+
+  setKeeperEditing(editing) {
+    set({ keeperEditing: editing });
+  },
+
+  async _handleKeeperCommand(agentId, message, command) {
+    const rest = message.replace(/\[\w+[-\w]*\]|\b(?:save|append|update|delete|view|doc|link|read|instruct)\b/i, '').trim();
+    const tags = (rest.match(/#[\w/.-]+/g) || []).map(t => t.replace(/^#/, ''));
+
+    const addSystemMsg = (text) => {
+      get().addChatMessage(agentId, 'system', text);
+    };
+
+    try {
+      switch (command) {
+        case 'instruct': {
+          set({ keeperInstructOpen: true });
+          return true;
+        }
+
+        case 'save': {
+          if (tags.length === 0) { addSystemMsg('Usage: save #tag your message here'); return true; }
+          const content = rest.replace(/#[\w/.-]+/g, '').trim();
+          if (!content) { addSystemMsg('Usage: save #tag your message here'); return true; }
+          await get().saveKeeperItem(tags[0], content);
+          addSystemMsg(`Saved to #${tags[0]}`);
+          return { passthrough: content };
+        }
+
+        case 'append': {
+          if (tags.length === 0) { addSystemMsg('Usage: append #tag content to add'); return true; }
+          const content = rest.replace(/#[\w/.-]+/g, '').trim();
+          if (!content) { addSystemMsg('Usage: append #tag content to add'); return true; }
+          await get().appendKeeperItem(tags[0], content);
+          addSystemMsg(`Appended to #${tags[0]}`);
+          return { passthrough: content };
+        }
+
+        case 'update': {
+          if (tags.length === 0) { addSystemMsg('Usage: [update] #tag'); return true; }
+          get().addChatMessage(agentId, 'user', message, false);
+          const existing = await get().getKeeperItem(tags[0]);
+          set({ keeperEditing: { tag: tags[0], content: existing?.content || '', isNew: !existing } });
+          return true;
+        }
+
+        case 'delete': {
+          if (tags.length === 0) { addSystemMsg('Usage: [delete] #tag'); return true; }
+          get().addChatMessage(agentId, 'user', message, false);
+          await get().deleteKeeperItem(tags[0]);
+          addSystemMsg(`Deleted #${tags[0]}`);
+          return true;
+        }
+
+        case 'view': {
+          if (tags.length === 0) { addSystemMsg('Usage: [view] #tag'); return true; }
+          get().addChatMessage(agentId, 'user', message, false);
+          const item = await get().getKeeperItem(tags[0]);
+          if (item) {
+            set({ keeperEditing: { tag: tags[0], content: item.content, isNew: false, readOnly: true } });
+          } else {
+            addSystemMsg(`#${tags[0]} not found`);
+          }
+          return true;
+        }
+
+        case 'read': {
+          if (tags.length === 0) { addSystemMsg('Usage: [read] #tag1 #tag2 ...'); return true; }
+          get().addChatMessage(agentId, 'user', message, false);
+          const readBrief = await api.post('/keeper/pull', { tags });
+          if (readBrief?.brief) {
+            await api.post(`/agents/${encodeURIComponent(agentId)}/instruct`, {
+              message: `Here is context from my tagged memories:\n\n${readBrief.brief}`,
+            });
+            addSystemMsg(`Sent ${tags.map(t => '#' + t).join(', ')} to agent`);
+          } else {
+            addSystemMsg(`No memories found for ${tags.map(t => '#' + t).join(', ')}`);
+          }
+          return true;
+        }
+
+        case 'doc': {
+          if (tags.length === 0) { addSystemMsg('Usage: [doc] #tag'); return true; }
+          get().addChatMessage(agentId, 'user', message, false);
+          addSystemMsg(`Generating doc for #${tags[0]}...`);
+          const history = get().chatHistory[agentId] || [];
+          const result = await api.post('/keeper/doc', { tag: tags[0], chatHistory: history, agentId });
+          if (result?.content) {
+            addSystemMsg(`Doc #${tags[0]} generated (${result.size}B)`);
+            set({ keeperEditing: { tag: tags[0], content: result.content, isNew: false } });
+          }
+          return true;
+        }
+
+        case 'link': {
+          const linkMatch = rest.match(/^((?:#[\w/.-]+\s*)+)\s+(.+)$/);
+          if (!linkMatch || tags.length === 0) { addSystemMsg('Usage: [link] #tag path/to/doc'); return true; }
+          const docPath = linkMatch[2].trim();
+          get().addChatMessage(agentId, 'user', message, false);
+          await api.post('/keeper/link', { tag: tags[0], docPath });
+          addSystemMsg(`Linked #${tags[0]} → ${docPath}`);
+          return true;
+        }
+      }
+    } catch (err) {
+      addSystemMsg(`Keeper error: ${err.message}`);
+      return true;
+    }
+    return false;
+  },
+
   // ── Teams ─────────────────────────────────────────────────
 
   async fetchTeams() {
@@ -1834,7 +2031,6 @@ export const useGrooveStore = create((set, get) => ({
         ...(tlc?.reasoningEffort != null && { teamReasoningEffort: tlc.reasoningEffort }),
         ...(tlc?.temperature != null && { teamTemperature: tlc.temperature }),
         ...(tlc?.verbosity != null && { teamVerbosity: tlc.verbosity }),
-        ...(tlc?.mode && { mode: tlc.mode }),
       };
       const result = await api.post('/recommended-team/launch', body);
       const totalOk = (result.launched || 0) + (result.reused || 0);
@@ -2487,6 +2683,16 @@ export const useGrooveStore = create((set, get) => ({
   },
 
   async instructAgent(id, message) {
+    // ── Keeper command interception ─────────────────────────
+    const keeperCmd = message.match(/\[(save|append|update|delete|view|doc|link|read|instruct)\]|\b(save|append|update|delete|view|doc|link|read)\b(?=\s+#[\w/.-])/i);
+    if (keeperCmd) {
+      const handled = await get()._handleKeeperCommand(id, message, (keeperCmd[1] || keeperCmd[2]).toLowerCase());
+      if (handled === true) return { status: 'keeper_handled' };
+      if (handled?.passthrough) {
+        message = handled.passthrough;
+      }
+    }
+
     get().addChatMessage(id, 'user', message, false);
     set((s) => ({ thinkingAgents: new Set([...s.thinkingAgents, id]) }));
 
@@ -3022,10 +3228,27 @@ export const useGrooveStore = create((set, get) => ({
     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;
-    const message = `Instruction: ${instruction}\nFile: ${filePath}\nLines ${lineStart}-${lineEnd}:\n\`\`\`\n${selectedCode}\n\`\`\``;
-    await get().instructAgent(agentId, message);
+    get().attachSnippet({
+      type: 'code',
+      instruction,
+      filePath,
+      lineStart,
+      lineEnd,
+      code: selectedCode,
+    });
   },
 
   async fetchGitStatus() {
@@ -3640,11 +3863,17 @@ export const useGrooveStore = create((set, get) => ({
           const payload = line.slice(6);
           if (payload === '[DONE]') continue;
           try {
-            const chunk = JSON.parse(payload);
-            if (chunk.type === 'reasoning' && chunk.content) {
+            const parsed = JSON.parse(payload);
+
+            // Support both raw OpenAI format (piped) and legacy wrapper format
+            const delta = parsed.choices?.[0]?.delta;
+            const reasoningText = delta?.reasoning_content || (parsed.type === 'reasoning' ? parsed.content : null);
+            const contentText = delta?.content || (parsed.type === 'token' ? parsed.content : null);
+
+            if (reasoningText) {
               if (!firstTokenTime) firstTokenTime = performance.now();
               tokenCount++;
-              fullReasoning += chunk.content;
+              fullReasoning += reasoningText;
               set((s) => {
                 const sessions = s.labSessions.map((sess) => {
                   if (sess.id !== sessionId) return sess;
@@ -3655,10 +3884,10 @@ export const useGrooveStore = create((set, get) => ({
                 return { labSessions: sessions };
               });
             }
-            if (chunk.type === 'token' && chunk.content) {
+            if (contentText) {
               if (!firstTokenTime) firstTokenTime = performance.now();
               tokenCount++;
-              fullContent += chunk.content;
+              fullContent += contentText;
               set((s) => {
                 const sessions = s.labSessions.map((sess) => {
                   if (sess.id !== sessionId) return sess;
@@ -3669,11 +3898,13 @@ export const useGrooveStore = create((set, get) => ({
                 return { labSessions: sessions };
               });
             }
-            if (chunk.type === 'done' && chunk.metrics) {
+
+            // Handle done event (legacy wrapper) or finish_reason (raw OpenAI)
+            if (parsed.type === 'done' && parsed.metrics) {
               const elapsed = performance.now() - startTime;
               const ttft = firstTokenTime ? firstTokenTime - startTime : null;
               const tps = tokenCount > 0 && elapsed > 0 ? (tokenCount / (elapsed / 1000)) : null;
-              const msgMetrics = { ttft, tokensPerSec: tps, tokens: tokenCount, generationTime: elapsed, ...chunk.metrics };
+              const msgMetrics = { ttft, tokensPerSec: tps, tokens: tokenCount, generationTime: elapsed, ...parsed.metrics };
 
               set((s) => {
                 const tpsHist = [...s.labMetrics.tokensPerSecHistory, tps].slice(-10);
@@ -3687,15 +3918,15 @@ export const useGrooveStore = create((set, get) => ({
                   labSessions: sessions,
                   labMetrics: {
                     ttft, tokensPerSec: tps, tokensPerSecHistory: tpsHist,
-                    memory: chunk.metrics.memoryUsage || s.labMetrics.memory,
-                    totalTokens: s.labMetrics.totalTokens + (chunk.metrics.totalTokens || tokenCount),
-                    generationTime: chunk.metrics.generationTime || elapsed,
+                    memory: parsed.metrics.memoryUsage || s.labMetrics.memory,
+                    totalTokens: s.labMetrics.totalTokens + (parsed.metrics.totalTokens || tokenCount),
+                    generationTime: parsed.metrics.generationTime || elapsed,
                   },
                 };
               });
             }
-            if (chunk.type === 'error') {
-              throw new Error(chunk.error || 'Inference error');
+            if (parsed.type === 'error') {
+              throw new Error(parsed.error || 'Inference error');
             }
           } catch (e) {
             if (e.message && e.message !== 'Inference error' && !e.message.startsWith('HTTP ')) continue;
@@ -3704,14 +3935,24 @@ export const useGrooveStore = create((set, get) => ({
         }
       }
 
-      // Final metrics if no done event came
-      if (!get().labSessions.find((s) => s.id === sessionId)?.messages.slice(-1)[0]?.metrics) {
-        const elapsed = performance.now() - startTime;
-        const ttft = firstTokenTime ? firstTokenTime - startTime : null;
-        const tps = tokenCount > 0 && elapsed > 0 ? (tokenCount / (elapsed / 1000)) : null;
+      // Compute final metrics from client-side timing
+      const elapsed = performance.now() - startTime;
+      const ttft = firstTokenTime ? firstTokenTime - startTime : null;
+      const tps = tokenCount > 0 && elapsed > 0 ? (tokenCount / (elapsed / 1000)) : null;
+      if (tokenCount > 0) {
         set((s) => {
           const tpsHist = [...s.labMetrics.tokensPerSecHistory, tps].slice(-10);
+          const sessions = s.labSessions.map((sess) => {
+            if (sess.id !== sessionId) return sess;
+            const msgs = [...sess.messages];
+            const last = msgs[msgs.length - 1];
+            if (!last?.metrics) {
+              msgs[msgs.length - 1] = { ...last, metrics: { ttft, tokensPerSec: tps, tokens: tokenCount, generationTime: elapsed } };
+            }
+            return { ...sess, messages: msgs };
+          });
           return {
+            labSessions: sessions,
             labMetrics: { ...s.labMetrics, ttft, tokensPerSec: tps, tokensPerSecHistory: tpsHist, totalTokens: s.labMetrics.totalTokens + tokenCount, generationTime: elapsed },
           };
         });
@@ -3836,4 +4077,45 @@ export const useGrooveStore = create((set, get) => ({
       return false;
     }
   },
+
+  // ── Integration Agent Install ────────────────────────────
+
+  async installViaExistingAgent(integration, agentId) {
+    const message = buildIntegrationPrompt(integration);
+    await get().instructAgent(agentId, message);
+    get().setActiveView('agents');
+    get().selectAgent(agentId);
+  },
+
+  async spawnIntegrationTeam(integration) {
+    const team = await get().createTeam(integration.name);
+    const prompt = buildIntegrationPrompt(integration);
+    const agent = await get().spawnAgent({ role: 'planner', prompt, teamId: team.id });
+    get().setActiveView('agents');
+    get().selectAgent(agent.id);
+    return agent;
+  },
 }));
+
+function buildIntegrationPrompt(integration) {
+  const lines = [
+    `Set up the "${integration.name}" integration for this project.`,
+    '',
+  ];
+  if (integration.description) lines.push(`**Description:** ${integration.description}`);
+  if (integration.npmPackage) lines.push(`**npm package:** ${integration.npmPackage}`);
+  if (integration.authType) lines.push(`**Auth type:** ${integration.authType}`);
+  if (integration.envKeys?.length) {
+    lines.push('', '**Environment keys required:**');
+    for (const k of integration.envKeys) {
+      lines.push(`- \`${k.key}\` — ${k.label}${k.required ? ' (required)' : ''}`);
+    }
+  }
+  if (integration.setupSteps?.length) {
+    lines.push('', '**Setup steps:**');
+    integration.setupSteps.forEach((step, i) => lines.push(`${i + 1}. ${step}`));
+  }
+  if (integration.setupUrl) lines.push(``, `**Setup URL:** ${integration.setupUrl}`);
+  if (integration.agentInstructions) lines.push('', `**Agent instructions:** ${integration.agentInstructions}`);
+  return lines.join('\n');
+}