tuna-agent 0.1.21 → 0.1.23

package/dist/agents/claude-code-adapter.js

@@ -671,29 +671,33 @@ export class ClaudeCodeAdapter {
         const MIN_DESCRIPTION_LENGTH = 20;
         if (task.description.length < MIN_DESCRIPTION_LENGTH)
             return;
-        const taskContext = task.description.substring(0, 150);
-        const resultContext = resultSummary.substring(0, 200);
-        const statusLabel = status === 'done' ? 'COMPLETED' : 'FAILED';
-        // Structured reflection: what was asked, what happened, what to remember
-        const parts = [];
-        if (status === 'failed') {
-            parts.push(`[TASK FAILED] "${taskContext}"`);
-            parts.push(`Error: ${resultContext}`);
-            parts.push(`Lesson: This type of task failed — review approach next time`);
-        }
-        else {
-            parts.push(`[TASK ${statusLabel}] "${taskContext}"`);
-            parts.push(`Result: ${resultContext}`);
-        }
-        const memoryText = parts.join('. ');
         try {
-            console.log(`[Reflection] Storing reflection for task ${task.id} (${status})`);
-            const { callMem0AddMemory } = await import('../mcp/setup.js');
-            await callMem0AddMemory(memoryText, this.agentConfig.name);
-            console.log(`[Reflection] Reflection stored for task ${task.id}`);
+            // Step 1: Generate AI-powered reflection via Ollama
+            console.log(`[Reflection] Generating AI reflection for task ${task.id} (${status})`);
+            const { callMem0Reflect, callMem0AddMemory } = await import('../mcp/setup.js');
+            const aiReflection = await callMem0Reflect(task.description, resultSummary, status);
+            if (!aiReflection) {
+                console.log(`[Reflection] No meaningful lesson — skipping storage for task ${task.id}`);
+                return;
+            }
+            // Step 2: Store the AI-generated reflection in Mem0
+            console.log(`[Reflection] Storing: "${aiReflection.substring(0, 100)}..."`);
+            await callMem0AddMemory(aiReflection, this.agentConfig.name);
+            console.log(`[Reflection] Stored for task ${task.id}`);
         }
         catch (err) {
-            console.warn(`[Reflection] Failed for task ${task.id}:`, err instanceof Error ? err.message : err);
+            // Fallback: store basic reflection if AI reflection fails
+            console.warn(`[Reflection] AI reflection failed, using fallback for task ${task.id}:`, err instanceof Error ? err.message : err);
+            try {
+                const fallback = status === 'failed'
+                    ? `Task failed: "${task.description.substring(0, 150)}". Error: ${resultSummary.substring(0, 200)}`
+                    : `Task completed: "${task.description.substring(0, 150)}". Result: ${resultSummary.substring(0, 200)}`;
+                const { callMem0AddMemory } = await import('../mcp/setup.js');
+                await callMem0AddMemory(fallback, this.agentConfig.name);
+            }
+            catch {
+                // Both AI and fallback failed — give up silently
+            }
         }
     }
     /**

package/dist/mcp/setup.d.ts

@@ -9,6 +9,12 @@ export declare function callMem0AddMemory(text: string, agentName: string): Prom
  * Returns array of memory texts sorted by relevance.
  */
 export declare function callMem0SearchMemory(query: string, agentName: string, limit?: number): Promise<string[]>;
+/**
+ * Generate AI-powered reflection from task results using Ollama.
+ * Calls mem0-reflect script on relabs01 via SSH.
+ * Returns a concise lesson learned, or empty string if nothing meaningful.
+ */
+export declare function callMem0Reflect(taskDesc: string, resultSummary: string, status: 'done' | 'failed'): Promise<string>;
 /**
  * Generate MCP server config file for Claude Code.
  * This file is auto-detected by runClaude and passed via --mcp-config.

package/dist/mcp/setup.js

@@ -110,7 +110,13 @@ export async function callMem0SearchMemory(query, agentName, limit = 5) {
             try {
                 const data = JSON.parse(stdout.trim());
                 const results = (data.results || []);
-                resolve(results.map(r => r.text));
+                // Only keep memories with relevance score >= 0.6
+                const relevant = results.filter(r => r.score >= 0.6);
+                if (relevant.length > 0) {
+                    console.log(`[Mem0 Search] ${relevant.length}/${results.length} memories above threshold (scores: ${relevant.map(r => r.score.toFixed(2)).join(', ')})`);
+                    relevant.forEach((r, i) => console.log(`[Mem0 Search]   ${i + 1}. [${r.score.toFixed(2)}] ${r.text.substring(0, 100)}`));
+                }
+                resolve(relevant.map(r => r.text));
             }
             catch {
                 resolve([]);
@@ -118,6 +124,67 @@ export async function callMem0SearchMemory(query, agentName, limit = 5) {
         });
     });
 }
+/**
+ * Generate AI-powered reflection from task results using Ollama.
+ * Calls mem0-reflect script on relabs01 via SSH.
+ * Returns a concise lesson learned, or empty string if nothing meaningful.
+ */
+export async function callMem0Reflect(taskDesc, resultSummary, status) {
+    if (!MEM0_SSH_HOST)
+        return '';
+    const { execFile } = await import('child_process');
+    const input = JSON.stringify({
+        task: taskDesc.substring(0, 300),
+        result: resultSummary.substring(0, 500),
+        status,
+    });
+    return new Promise((resolve) => {
+        let cmd;
+        let args;
+        let options = {};
+        if (MEM0_SSH_HOST === 'local') {
+            cmd = 'mem0-reflect';
+            args = [];
+            options.env = { ...process.env };
+        }
+        else {
+            cmd = 'ssh';
+            args = ['-p', MEM0_SSH_PORT, '-o', 'StrictHostKeyChecking=no'];
+            if (MEM0_SSH_KEY)
+                args.push('-i', MEM0_SSH_KEY);
+            args.push(MEM0_SSH_HOST, 'mem0-reflect');
+        }
+        const child = execFile(cmd, args, { ...options, timeout: 90000 }, (err, stdout) => {
+            if (err) {
+                console.warn(`[Mem0 Reflect] Failed: ${err.message}`);
+                resolve('');
+                return;
+            }
+            try {
+                const data = JSON.parse(stdout.trim());
+                if (data.error) {
+                    console.warn(`[Mem0 Reflect] Error: ${data.error}`);
+                    resolve('');
+                    return;
+                }
+                if (data.skipped) {
+                    console.log(`[Mem0 Reflect] Skipped — nothing meaningful to learn`);
+                    resolve('');
+                    return;
+                }
+                // Clean up: remove trailing SKIP if LLM appended it
+                let reflection = (data.reflection || '').replace(/\s*SKIP\s*$/i, '').trim();
+                resolve(reflection);
+            }
+            catch {
+                resolve('');
+            }
+        });
+        // Send input via stdin
+        child.stdin?.write(input);
+        child.stdin?.end();
+    });
+}
 /**
  * Build Mem0 MCP server config for an agent.
  * - MEM0_SSH_HOST="local": run mem0-mcp directly (Mem0 infra on same machine)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"