tuna-agent 0.1.24 → 0.1.26

package/dist/agents/claude-code-adapter.d.ts

@@ -5,6 +5,8 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     readonly type: AgentType;
     readonly displayName = "Claude Code";
     private readonly agentConfig;
+    private taskCount;
+    private static readonly PATTERN_CHECK_INTERVAL;
     constructor(config: AgentConfig);
     checkHealth(): Promise<{
         ok: boolean;
@@ -26,5 +28,10 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
         comment?: string;
         cwd: string;
     }): Promise<void>;
+    /**
+     * Self-Improvement: detect patterns from Mem0 and update CLAUDE.md.
+     * Runs every N tasks to evolve the agent's permanent knowledge.
+     */
+    runSelfImprovement(cwd: string): Promise<void>;
     dispose(): Promise<void>;
 }

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

@@ -12,6 +12,8 @@ export class ClaudeCodeAdapter {
     type = 'claude-code';
     displayName = 'Claude Code';
     agentConfig;
+    taskCount = 0;
+    static PATTERN_CHECK_INTERVAL = 5; // Check patterns every N tasks
     constructor(config) {
         this.agentConfig = config;
     }
@@ -206,6 +208,9 @@ export class ClaudeCodeAdapter {
                     }
                     // Track last output for reflection
                     lastTaskOutput = turnAccumulatedText.trim();
+                    if (lastTaskOutput) {
+                        console.log(`[Reflection] Captured ${lastTaskOutput.length} chars of task output for reflection`);
+                    }
                     // Send finalized message for the last turn's remaining text
                     if (turnAccumulatedText.trim()) {
                         ws.sendPMMessage(task.id, {
@@ -252,7 +257,9 @@ export class ClaudeCodeAdapter {
                             console.log(`[ClaudeCode] No follow-up after ${FOLLOW_UP_TIMEOUT_MS / 1000}s — closing task`);
                             pendingInputResolvers.delete(task.id);
                             const timeoutOutput = lastTaskOutput || 'Task completed (no follow-up)';
-                            this.runReflection(task, timeoutOutput, 'done', task.repoPath).catch(() => { });
+                            this.runReflection(task, timeoutOutput, 'done', task.repoPath)
+                                .then(() => this.runSelfImprovement(task.repoPath))
+                                .catch(() => { });
                             return;
                         }
                         throw err;
@@ -284,7 +291,9 @@ export class ClaudeCodeAdapter {
                 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 with actual output (non-blocking)
-                this.runReflection(task, lastTaskOutput || 'Task completed without text output', 'done', task.repoPath).catch(() => { });
+                this.runReflection(task, lastTaskOutput || 'Task completed without text output', 'done', task.repoPath)
+                    .then(() => this.runSelfImprovement(task.repoPath))
+                    .catch(() => { });
             }
             finally {
                 cleanupAttachments(task.id);
@@ -677,7 +686,7 @@ export class ClaudeCodeAdapter {
             return;
         try {
             // Step 1: Generate AI-powered reflection via Ollama
-            console.log(`[Reflection] Generating AI reflection for task ${task.id} (${status})`);
+            console.log(`[Reflection] Generating AI reflection for task ${task.id} (${status}), input: ${resultSummary.substring(0, 150)}...`);
             const { callMem0Reflect, callMem0AddMemory } = await import('../mcp/setup.js');
             const aiReflection = await callMem0Reflect(task.description, resultSummary, status);
             if (!aiReflection) {
@@ -727,6 +736,60 @@ export class ClaudeCodeAdapter {
             console.warn(`[Rating→Mem0] Failed:`, err instanceof Error ? err.message : err);
         }
     }
+    /**
+     * Self-Improvement: detect patterns from Mem0 and update CLAUDE.md.
+     * Runs every N tasks to evolve the agent's permanent knowledge.
+     */
+    async runSelfImprovement(cwd) {
+        if (!process.env.MEM0_SSH_HOST)
+            return;
+        this.taskCount++;
+        if (this.taskCount % ClaudeCodeAdapter.PATTERN_CHECK_INTERVAL !== 0)
+            return;
+        try {
+            console.log(`[Self-Improve] Running pattern detection (every ${ClaudeCodeAdapter.PATTERN_CHECK_INTERVAL} tasks, count=${this.taskCount})`);
+            const { callMem0Patterns } = await import('../mcp/setup.js');
+            const patterns = await callMem0Patterns(this.agentConfig.name, 3);
+            if (patterns.length === 0) {
+                console.log(`[Self-Improve] No patterns detected yet`);
+                return;
+            }
+            // Read current CLAUDE.md to check for existing rules
+            const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+            let existingContent = '';
+            if (fs.existsSync(claudeMdPath)) {
+                existingContent = fs.readFileSync(claudeMdPath, 'utf-8');
+            }
+            // Filter out patterns that are already in CLAUDE.md
+            const newPatterns = patterns.filter(p => {
+                // Simple dedup: check if rule text (or close match) already exists
+                const ruleNormalized = p.rule.toLowerCase().replace(/[^a-z0-9\s]/g, '');
+                return !existingContent.toLowerCase().includes(ruleNormalized.substring(0, 50));
+            });
+            if (newPatterns.length === 0) {
+                console.log(`[Self-Improve] ${patterns.length} patterns found but all already in CLAUDE.md`);
+                return;
+            }
+            // Append new rules to CLAUDE.md under "## Learned Rules"
+            const SECTION_HEADER = '## Learned Rules';
+            const rulesBlock = newPatterns.map(p => `- ${p.rule} (confidence: ${p.confidence})`).join('\n');
+            if (existingContent.includes(SECTION_HEADER)) {
+                // Append to existing section
+                const updatedContent = existingContent.replace(SECTION_HEADER, `${SECTION_HEADER}\n${rulesBlock}`);
+                fs.writeFileSync(claudeMdPath, updatedContent);
+            }
+            else {
+                // Add new section at the end
+                const separator = existingContent.endsWith('\n') ? '\n' : '\n\n';
+                fs.writeFileSync(claudeMdPath, existingContent + separator + `${SECTION_HEADER}\n${rulesBlock}\n`);
+            }
+            console.log(`[Self-Improve] Added ${newPatterns.length} new rules to CLAUDE.md:`);
+            newPatterns.forEach(p => console.log(`[Self-Improve]   - ${p.rule}`));
+        }
+        catch (err) {
+            console.warn(`[Self-Improve] Failed:`, err instanceof Error ? err.message : err);
+        }
+    }
     async dispose() {
         // No persistent resources to clean up
     }

package/dist/mcp/setup.d.ts

@@ -9,6 +9,15 @@ 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[]>;
+/**
+ * Detect patterns from accumulated memories via mem0-patterns script.
+ * Returns synthesized rules from clusters of similar memories.
+ */
+export declare function callMem0Patterns(agentName: string, minCluster?: number): Promise<Array<{
+    rule: string;
+    confidence: number;
+    sources: string[];
+}>>;
 /**
  * Generate AI-powered reflection from task results using Ollama.
  * Calls mem0-reflect script on relabs01 via SSH.

package/dist/mcp/setup.js

@@ -124,6 +124,51 @@ export async function callMem0SearchMemory(query, agentName, limit = 5) {
         });
     });
 }
+/**
+ * Detect patterns from accumulated memories via mem0-patterns script.
+ * Returns synthesized rules from clusters of similar memories.
+ */
+export async function callMem0Patterns(agentName, minCluster = 3) {
+    if (!MEM0_SSH_HOST)
+        return [];
+    const { execFile } = await import('child_process');
+    const safeAgentName = agentName.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '') || 'agent';
+    const input = JSON.stringify({ user_id: safeAgentName, min_cluster: minCluster });
+    return new Promise((resolve) => {
+        let cmd;
+        let args;
+        let options = {};
+        if (MEM0_SSH_HOST === 'local') {
+            cmd = 'mem0-patterns';
+            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-patterns');
+        }
+        const child = execFile(cmd, args, { ...options, timeout: 120000 }, (err, stdout) => {
+            if (err) {
+                console.warn(`[Mem0 Patterns] Failed: ${err.message}`);
+                resolve([]);
+                return;
+            }
+            try {
+                const data = JSON.parse(stdout.trim());
+                console.log(`[Mem0 Patterns] ${data.total_memories} memories, ${data.clusters} clusters, ${(data.patterns || []).length} patterns found`);
+                resolve(data.patterns || []);
+            }
+            catch {
+                resolve([]);
+            }
+        });
+        child.stdin?.write(input);
+        child.stdin?.end();
+    });
+}
 /**
  * Generate AI-powered reflection from task results using Ollama.
  * Calls mem0-reflect script on relabs01 via SSH.

package/package.json

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