tuna-agent 0.1.74 → 0.1.76

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

@@ -930,8 +930,45 @@ export class ClaudeCodeAdapter {
                     }
                 }
             }
-            // Filter: skip patterns similar to ANY existing rule
-            const newPatterns = patterns.filter(p => {
+            // Filter 1: Quality gate — reject garbage rules
+            const MAX_LEARNED_RULES = 20;
+            const MIN_CONFIDENCE = 3;
+            const qualityPatterns = patterns.filter(p => {
+                const r = p.rule.trim();
+                // Confidence gate — only persist rules seen 3+ times
+                if (p.confidence < MIN_CONFIDENCE) {
+                    console.log(`[Self-Improve] Skipped (low confidence ${p.confidence}): "${r.substring(0, 80)}"`);
+                    return false;
+                }
+                // Reject generic platitudes
+                if (/^always (prioritize|verify|ensure|keep an eye|strive|validate|check|monitor)/i.test(r)) {
+                    console.log(`[Self-Improve] Skipped (generic): "${r.substring(0, 80)}"`);
+                    return false;
+                }
+                if (/^(prior to|when making decisions|before engaging|before using)/i.test(r)) {
+                    console.log(`[Self-Improve] Skipped (generic): "${r.substring(0, 80)}"`);
+                    return false;
+                }
+                // Reject rules that look like app descriptions (hallucination from research)
+                if (/\b(block all apps|learned to read|language required|learnlock|user education)\b/i.test(r)) {
+                    console.log(`[Self-Improve] Skipped (hallucinated from app idea): "${r.substring(0, 80)}"`);
+                    return false;
+                }
+                // Reject too short or too vague rules
+                if (r.length < 30) {
+                    console.log(`[Self-Improve] Skipped (too short): "${r}"`);
+                    return false;
+                }
+                return true;
+            });
+            // Cap total rules — if already at max, skip adding more
+            if (existingRules.length >= MAX_LEARNED_RULES) {
+                console.log(`[Self-Improve] Already at max ${MAX_LEARNED_RULES} rules — skipping`);
+                return;
+            }
+            const slotsAvailable = MAX_LEARNED_RULES - existingRules.length;
+            // Filter 2: skip patterns similar to ANY existing rule
+            const newPatterns = qualityPatterns.filter(p => {
                 return !existingRules.some(existing => ClaudeCodeAdapter.isSimilarRule(p.rule, existing));
             });
             // Also dedup among new patterns themselves
@@ -945,8 +982,8 @@ export class ClaudeCodeAdapter {
                 console.log(`[Self-Improve] ${patterns.length} patterns found but all similar to existing rules`);
                 return;
             }
-            // Cap at 3 new rules per run to avoid bloating
-            const toAdd = dedupedPatterns.slice(0, 3);
+            // Cap at 3 new rules per run, and respect total max
+            const toAdd = dedupedPatterns.slice(0, Math.min(3, slotsAvailable));
             // Append new rules at the END of the Learned Rules section
             const rulesBlock = toAdd.map(p => `- ${p.rule} (confidence: ${p.confidence})`).join('\n');
             if (existingContent.includes(SECTION_HEADER)) {

package/dist/executor/task-runner.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import os from 'os';
 import { spawn } from 'child_process';
+import { StringDecoder } from 'string_decoder';
 import { runClaude } from '../utils/claude-cli.js';
 import { validatePath } from '../utils/validate-path.js';
 const NEEDS_INPUT_MARKER = '"status":"NEEDS_INPUT"';
@@ -82,8 +83,9 @@ export async function runTask(task, onProgress, signal, confirmBeforeEdit) {
         let stdout = '';
         let stderr = '';
         let buffer = '';
+        const stdoutDecoder = new StringDecoder('utf8');
         proc.stdout.on('data', (chunk) => {
-            const text = chunk.toString();
+            const text = stdoutDecoder.write(chunk);
             stdout += text;
             buffer += text;
             const lines = buffer.split('\n');
@@ -100,8 +102,9 @@ export async function runTask(task, onProgress, signal, confirmBeforeEdit) {
                 }
             }
         });
+        const stderrDecoder = new StringDecoder('utf8');
         proc.stderr.on('data', (chunk) => {
-            stderr += chunk.toString();
+            stderr += stderrDecoder.write(chunk);
         });
         proc.on('close', (code) => {
             clearTimeout(timeoutTimer);

package/dist/mcp/setup.d.ts

@@ -5,11 +5,6 @@ import type { AgentConfig } from '../types/index.js';
  * Returns 0 if MEM0_HTTP_BASE is not set or request fails.
  */
 export declare function fetchMem0Count(agentName: string): Promise<number>;
-/**
- * Add memory via OpenMemory HTTP API (POST /api/v1/memories/).
- * Uses MEM0_HTTP_BASE if available, falls back to SSH+mem0-add.
- * OpenMemory API stores in both SQLite (metadata) + Qdrant (vectors) — correct path.
- */
 export declare function callMem0AddMemory(text: string, agentName: string): Promise<void>;
 /**
  * Search Mem0 for relevant memories before task execution.

package/dist/mcp/setup.js

@@ -65,9 +65,46 @@ export async function fetchMem0Count(agentName) {
  * Uses MEM0_HTTP_BASE if available, falls back to SSH+mem0-add.
  * OpenMemory API stores in both SQLite (metadata) + Qdrant (vectors) — correct path.
  */
+/**
+ * Validate memory text before storing. Returns null if valid, or rejection reason.
+ */
+function validateMemory(text) {
+    const t = text.trim();
+    // Too short — likely a fragment like "Upvoted 10 posts"
+    if (t.length < 60)
+        return `too short (${t.length} chars, min 60)`;
+    // Generic platitudes that waste memory
+    const genericPatterns = [
+        /^always (prioritize|verify|ensure|keep an eye|strive|validate|check)/i,
+        /^prior to (any|engaging|making|using)/i,
+        /^when making decisions/i,
+        /^(believe|believes) reddit is/i,
+        /^follow (accounts|verified)/i,
+        /^before (engaging|using|running)/i,
+    ];
+    if (genericPatterns.some(p => p.test(t)))
+        return `generic platitude`;
+    // Individual action fragments
+    const fragmentPatterns = [
+        /^(followed|upvoted|liked|joined|saved|has \d+|observed \d+)\b/i,
+        /^top product hunt product:/i,
+        /^plan(s)? to /i,
+        /^\w+ promoted to watching/i,
+        /^\w+ is top watching/i,
+    ];
+    if (fragmentPatterns.some(p => p.test(t)))
+        return `action fragment`;
+    return null;
+}
 export async function callMem0AddMemory(text, agentName) {
     if (!MEM0_SSH_HOST && !MEM0_HTTP_BASE)
         throw new Error('Mem0 not configured');
+    // Validate memory quality before storing
+    const rejection = validateMemory(text);
+    if (rejection) {
+        console.log(`[Mem0 Filter] Rejected memory (${rejection}): "${text.substring(0, 80)}..."`);
+        return;
+    }
     const safeAgentName = agentName.toLowerCase().replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '') || 'agent';
     // Try HTTP API first (OpenMemory) — stores in SQLite+Qdrant, shows up in counts
     // Falls through to SSH+curl if HTTP is not reachable (e.g. port not exposed externally)

package/package.json

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