tuna-agent 0.1.22 → 0.1.24

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

@@ -83,6 +83,7 @@ export class ClaudeCodeAdapter {
                     console.warn(`[Mem0 Recall] Failed:`, err instanceof Error ? err.message : err);
                 }
             }
+            let lastTaskOutput = ''; // Track last output for reflection
             try {
                 for (let round = 0; round < MAX_ROUNDS; round++) {
                     let streamMsgId = `team-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
@@ -203,6 +204,8 @@ export class ClaudeCodeAdapter {
                         this.runReflection(task, result.result, 'failed', cwd).catch(() => { });
                         return;
                     }
+                    // Track last output for reflection
+                    lastTaskOutput = turnAccumulatedText.trim();
                     // Send finalized message for the last turn's remaining text
                     if (turnAccumulatedText.trim()) {
                         ws.sendPMMessage(task.id, {
@@ -248,7 +251,8 @@ export class ClaudeCodeAdapter {
                         if (err instanceof Error && err.message === '__FOLLOW_UP_TIMEOUT__') {
                             console.log(`[ClaudeCode] No follow-up after ${FOLLOW_UP_TIMEOUT_MS / 1000}s — closing task`);
                             pendingInputResolvers.delete(task.id);
-                            this.runReflection(task, 'Agent Team task completed (no follow-up)', 'done', task.repoPath).catch(() => { });
+                            const timeoutOutput = lastTaskOutput || 'Task completed (no follow-up)';
+                            this.runReflection(task, timeoutOutput, 'done', task.repoPath).catch(() => { });
                             return;
                         }
                         throw err;
@@ -279,8 +283,8 @@ export class ClaudeCodeAdapter {
                 await new Promise(resolve => setTimeout(resolve, 150));
                 ws.sendPMMessage(task.id, { sender: 'pm', content: 'Task completed.' });
                 console.log(`[ClaudeCode] Agent Team task ${task.id} completed (${(totalDurationMs / 1000).toFixed(1)}s)`);
-                // Post-task reflection (non-blocking — runs after task is marked done)
-                this.runReflection(task, 'Agent Team task completed', 'done', task.repoPath).catch(() => { });
+                // Post-task reflection with actual output (non-blocking)
+                this.runReflection(task, lastTaskOutput || 'Task completed without text output', 'done', task.repoPath).catch(() => { });
             }
             finally {
                 cleanupAttachments(task.id);
@@ -671,29 +675,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

@@ -124,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.22",
+  "version": "0.1.24",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"