tuna-agent 0.1.160 → 0.1.162

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

@@ -74,6 +74,8 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     private static extractKeyPhrases;
     /** Check if two rules are semantically similar (>40% key phrase overlap). */
     private static isSimilarRule;
+    /** Cosine similarity between two equal-length embedding vectors. */
+    private static cosine;
     runSelfImprovement(cwd: string, agentId: string): Promise<void>;
     /**
      * Parse "## Learned Rules" section from CLAUDE.md and store in learnedRulesMap.

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

@@ -924,6 +924,16 @@ export class ClaudeCodeAdapter {
         const overlap = phrasesA.filter(p => phrasesB.has(p)).length;
         return overlap / phrasesA.length > 0.4;
     }
+    /** Cosine similarity between two equal-length embedding vectors. */
+    static cosine(a, b) {
+        let dot = 0, na = 0, nb = 0;
+        for (let i = 0; i < a.length; i++) {
+            dot += a[i] * b[i];
+            na += a[i] * a[i];
+            nb += b[i] * b[i];
+        }
+        return (na && nb) ? dot / (Math.sqrt(na) * Math.sqrt(nb)) : 0;
+    }
     async runSelfImprovement(cwd, agentId) {
         if (!process.env.MEM0_SSH_HOST)
             return;
@@ -1057,8 +1067,48 @@ export class ClaudeCodeAdapter {
                 console.log(`[Self-Improve] ${patterns.length} patterns found but all similar to existing rules`);
                 return;
             }
+            // ACE-style semantic de-duplication (grow-and-refine): string matching misses
+            // reworded variants (e.g. "prioritize X.com over Threads ..." x11). Embed candidates
+            // + existing rules with mxbai-embed-large and drop near-duplicates by cosine.
+            // Fail-safe: if embeddings are unavailable, keep the string-deduped result.
+            let semanticPatterns = dedupedPatterns;
+            try {
+                const { callOllamaEmbedBatch } = await import('../mcp/setup.js');
+                const THRESHOLD = parseFloat(process.env.LEARN_DEDUP_THRESHOLD || '0.9');
+                const candTexts = dedupedPatterns.map(p => p.rule);
+                const embs = await callOllamaEmbedBatch([...candTexts, ...existingRules]);
+                if (embs && embs.length === candTexts.length + existingRules.length) {
+                    const candEmbs = embs.slice(0, candTexts.length);
+                    const existEmbs = embs.slice(candTexts.length);
+                    const kept = [];
+                    const keptEmbs = [];
+                    for (let i = 0; i < dedupedPatterns.length; i++) {
+                        const e = candEmbs[i];
+                        const dup = existEmbs.some(xe => ClaudeCodeAdapter.cosine(e, xe) >= THRESHOLD)
+                            || keptEmbs.some(ke => ClaudeCodeAdapter.cosine(e, ke) >= THRESHOLD);
+                        if (dup) {
+                            console.log(`[Self-Improve] Semantic dup dropped (>=${THRESHOLD}): "${dedupedPatterns[i].rule.substring(0, 80)}"`);
+                            continue;
+                        }
+                        kept.push(dedupedPatterns[i]);
+                        keptEmbs.push(e);
+                    }
+                    semanticPatterns = kept;
+                    console.log(`[Self-Improve] Semantic dedup: ${dedupedPatterns.length} -> ${kept.length} (threshold ${THRESHOLD})`);
+                }
+                else {
+                    console.log(`[Self-Improve] Embeddings unavailable — falling back to string dedup`);
+                }
+            }
+            catch (e) {
+                console.warn(`[Self-Improve] Semantic dedup error, using string dedup:`, e instanceof Error ? e.message : e);
+            }
+            if (semanticPatterns.length === 0) {
+                console.log(`[Self-Improve] All new patterns are semantic duplicates of existing rules`);
+                return;
+            }
             // Cap at 3 new rules per run, and respect total max
-            const toAdd = dedupedPatterns.slice(0, Math.min(3, slotsAvailable));
+            const toAdd = semanticPatterns.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/mcp/setup.d.ts

@@ -20,6 +20,7 @@ export declare function callMem0Patterns(agentName: string, minCluster?: number)
     confidence: number;
     sources: string[];
 }>>;
+export declare function callOllamaEmbedBatch(texts: string[]): Promise<number[][] | null>;
 /**
  * Generate AI-powered reflection from task results using Claude CLI (-p mode).
  * Spawns `claude -p <prompt>` locally — uses existing Claude subscription, no extra cost.

package/dist/mcp/setup.js

@@ -268,6 +268,61 @@ export async function callMem0Patterns(agentName, minCluster = 3) {
         child.stdin?.end();
     });
 }
+/**
+ * Embed an array of texts via Ollama batch endpoint (/api/embed), using the same
+ * transport as Mem0: direct HTTP in local mode, SSH+curl for remote agents.
+ * Used by ACE-style semantic de-duplication of learned rules. Returns null on any
+ * failure so callers can fall back to string matching (no regression).
+ */
+const EMBED_MODEL = process.env.LEARN_EMBED_MODEL || 'mxbai-embed-large';
+export async function callOllamaEmbedBatch(texts) {
+    if (texts.length === 0)
+        return [];
+    const body = JSON.stringify({ model: EMBED_MODEL, input: texts });
+    try {
+        if (MEM0_SSH_HOST && MEM0_SSH_HOST !== 'local') {
+            // Remote agent: SSH then curl Ollama on the Mem0 host (127.0.0.1:11434)
+            const { execFile } = await import('child_process');
+            const escaped = body.replace(/'/g, "'\\''");
+            const remoteCmd = `curl -s -m 60 -X POST http://127.0.0.1:11434/api/embed -H 'Content-Type: application/json' -d '${escaped}'`;
+            const args = ['-p', MEM0_SSH_PORT, '-o', 'StrictHostKeyChecking=accept-new'];
+            if (MEM0_SSH_KEY)
+                args.push('-i', MEM0_SSH_KEY);
+            args.push(MEM0_SSH_HOST, remoteCmd);
+            return await new Promise((resolve) => {
+                execFile('ssh', args, { timeout: 90000, maxBuffer: 32 * 1024 * 1024 }, (err, stdout) => {
+                    if (err) {
+                        console.warn(`[Embed] SSH failed: ${err.message}`);
+                        resolve(null);
+                        return;
+                    }
+                    try {
+                        resolve(JSON.parse(stdout.trim()).embeddings ?? null);
+                    }
+                    catch {
+                        resolve(null);
+                    }
+                });
+            });
+        }
+        // Local mode or HTTP base: direct call
+        const url = `${MEM0_ENV_VARS.MEM0_OLLAMA_URL}/api/embed`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body,
+            signal: AbortSignal.timeout(60000),
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data.embeddings ?? null;
+    }
+    catch (e) {
+        console.warn(`[Embed] Failed:`, e instanceof Error ? e.message : e);
+        return null;
+    }
+}
 /**
  * Generate AI-powered reflection from task results using Claude CLI (-p mode).
  * Spawns `claude -p <prompt>` locally — uses existing Claude subscription, no extra cost.

package/dist/utils/claude-cli.js

@@ -119,9 +119,13 @@ export function runClaude(options) {
         if (options.disallowedTools?.length) {
             args.push('--disallowedTools', options.disallowedTools.join(','));
         }
-        if (options.systemPrompt) {
-            args.push('--append-system-prompt', options.systemPrompt);
-        }
+        // Always steer agents to answer the user in Vietnamese, regardless of the
+        // language of the task/skill/context. Merged with any caller system prompt.
+        const LANG_DIRECTIVE = 'QUAN TRỌNG — NGÔN NGỮ PHẢN HỒI: Luôn trả lời, báo cáo và giao tiếp với người dùng bằng TIẾNG VIỆT, kể cả khi task, skill, code, tài liệu hay context viết bằng tiếng Anh. Giữ nguyên thuật ngữ kỹ thuật, tên riêng, lệnh, code; phần diễn giải/kết luận phải bằng tiếng Việt.';
+        const mergedSystemPrompt = options.systemPrompt
+            ? `${options.systemPrompt}\n\n${LANG_DIRECTIVE}`
+            : LANG_DIRECTIVE;
+        args.push('--append-system-prompt', mergedSystemPrompt);
         if (options.maxTurns) {
             args.push('--max-turns', String(options.maxTurns));
         }

package/package.json

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