tuna-agent 0.1.59 → 0.1.60

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

@@ -69,6 +69,10 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
      * Self-Improvement: detect patterns from Mem0 and update CLAUDE.md.
      * Runs every N tasks to evolve the agent's permanent knowledge.
      */
+    /** Extract key phrases (3+ word sequences) from a rule for similarity matching. */
+    private static extractKeyPhrases;
+    /** Check if two rules are semantically similar (>40% key phrase overlap). */
+    private static isSimilarRule;
     runSelfImprovement(cwd: string): Promise<void>;
     /**
      * Parse "## Learned Rules" section from CLAUDE.md and store in learnedRulesMap.

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

@@ -846,6 +846,24 @@ export class ClaudeCodeAdapter {
      * Self-Improvement: detect patterns from Mem0 and update CLAUDE.md.
      * Runs every N tasks to evolve the agent's permanent knowledge.
      */
+    /** Extract key phrases (3+ word sequences) from a rule for similarity matching. */
+    static extractKeyPhrases(text) {
+        const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, '').split(/\s+/).filter(w => w.length > 2);
+        const phrases = [];
+        for (let i = 0; i <= words.length - 3; i++) {
+            phrases.push(words.slice(i, i + 3).join(' '));
+        }
+        return phrases;
+    }
+    /** Check if two rules are semantically similar (>40% key phrase overlap). */
+    static isSimilarRule(ruleA, ruleB) {
+        const phrasesA = ClaudeCodeAdapter.extractKeyPhrases(ruleA);
+        const phrasesB = new Set(ClaudeCodeAdapter.extractKeyPhrases(ruleB));
+        if (phrasesA.length === 0)
+            return false;
+        const overlap = phrasesA.filter(p => phrasesB.has(p)).length;
+        return overlap / phrasesA.length > 0.4;
+    }
     async runSelfImprovement(cwd) {
         if (!process.env.MEM0_SSH_HOST)
             return;
@@ -860,41 +878,76 @@ export class ClaudeCodeAdapter {
                 console.log(`[Self-Improve] No patterns detected yet`);
                 return;
             }
-            // Read current CLAUDE.md to check for existing rules
+            // Read current CLAUDE.md and extract 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
+            // Parse existing rules from "## Learned Rules" section
+            const SECTION_HEADER = '## Learned Rules';
+            const existingRules = [];
+            const sectionIdx = existingContent.indexOf(SECTION_HEADER);
+            if (sectionIdx !== -1) {
+                const sectionContent = existingContent.substring(sectionIdx + SECTION_HEADER.length);
+                const nextSection = sectionContent.indexOf('\n## ');
+                const rulesText = nextSection !== -1 ? sectionContent.substring(0, nextSection) : sectionContent;
+                for (const line of rulesText.split('\n')) {
+                    const trimmed = line.trim();
+                    if (trimmed.startsWith('- ')) {
+                        // Strip confidence suffix
+                        const ruleText = trimmed.replace(/\s*\(confidence:\s*[\d.]+\)\s*$/, '').substring(2);
+                        if (ruleText)
+                            existingRules.push(ruleText);
+                    }
+                }
+            }
+            // Filter: skip patterns similar to ANY existing rule
             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));
+                return !existingRules.some(existing => ClaudeCodeAdapter.isSimilarRule(p.rule, existing));
             });
-            if (newPatterns.length === 0) {
-                console.log(`[Self-Improve] ${patterns.length} patterns found but all already in CLAUDE.md`);
+            // Also dedup among new patterns themselves
+            const dedupedPatterns = [];
+            for (const p of newPatterns) {
+                const isDup = dedupedPatterns.some(existing => ClaudeCodeAdapter.isSimilarRule(p.rule, existing.rule));
+                if (!isDup)
+                    dedupedPatterns.push(p);
+            }
+            if (dedupedPatterns.length === 0) {
+                console.log(`[Self-Improve] ${patterns.length} patterns found but all similar to existing rules`);
                 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');
+            // Cap at 3 new rules per run to avoid bloating
+            const toAdd = dedupedPatterns.slice(0, 3);
+            // 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)) {
-                // Append to existing section
-                const updatedContent = existingContent.replace(SECTION_HEADER, `${SECTION_HEADER}\n${rulesBlock}`);
-                fs.writeFileSync(claudeMdPath, updatedContent);
+                // Find end of Learned Rules section (next ## or end of file)
+                const headerIdx = existingContent.indexOf(SECTION_HEADER);
+                const afterHeader = existingContent.substring(headerIdx + SECTION_HEADER.length);
+                const nextSectionIdx = afterHeader.indexOf('\n## ');
+                if (nextSectionIdx !== -1) {
+                    // Insert before next section
+                    const insertPos = headerIdx + SECTION_HEADER.length + nextSectionIdx;
+                    const updatedContent = existingContent.substring(0, insertPos) + '\n' + rulesBlock + existingContent.substring(insertPos);
+                    fs.writeFileSync(claudeMdPath, updatedContent);
+                }
+                else {
+                    // Append at end of file
+                    const ending = existingContent.endsWith('\n') ? '' : '\n';
+                    fs.writeFileSync(claudeMdPath, existingContent + ending + rulesBlock + '\n');
+                }
             }
             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`);
             }
-            this.metrics.patternsLearnedCount += newPatterns.length;
-            this.metrics.rulesCount += newPatterns.length;
+            this.metrics.patternsLearnedCount += toAdd.length;
+            this.metrics.rulesCount += toAdd.length;
             this.metrics.lastPatternAt = new Date().toISOString();
-            this.metrics.latestLearnedRule = newPatterns[newPatterns.length - 1].rule.substring(0, 500);
-            console.log(`[Self-Improve] Added ${newPatterns.length} new rules to CLAUDE.md:`);
-            newPatterns.forEach(p => console.log(`[Self-Improve]   - ${p.rule}`));
+            this.metrics.latestLearnedRule = toAdd[toAdd.length - 1].rule.substring(0, 500);
+            console.log(`[Self-Improve] Added ${toAdd.length} new rules to CLAUDE.md:`);
+            toAdd.forEach(p => console.log(`[Self-Improve]   - ${p.rule}`));
             // Sync learned rules to heartbeat metrics
             this.parseLearnedRules(claudeMdPath);
         }

package/package.json

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