tuna-agent 0.1.75 → 0.1.77

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/daemon/extension-handlers.d.ts

@@ -61,3 +61,8 @@ export interface CharProfile {
 export declare function handleListCharacters(ws: AgentWebSocketClient, code: string, taskId: string): void;
 export declare function handleCreateCharacter(ws: AgentWebSocketClient, code: string, taskId: string, name: string, displayName: string, prompt: string, outputCount?: number, orientation?: string): Promise<void>;
 export declare function handleSaveCharacterSelection(ws: AgentWebSocketClient, code: string, taskId: string, characterId: string, selectedImages: string[]): void;
+/**
+ * Sync apps from the agent's knowledge base.
+ * Reads knowledge items, identifies app-related documents, extracts app info.
+ */
+export declare function handleSyncApps(ws: AgentWebSocketClient, code: string, taskId: string, apiUrl: string, agentToken: string, agentId: string): Promise<void>;

package/dist/daemon/extension-handlers.js

@@ -890,6 +890,120 @@ export function handleSaveCharacterSelection(ws, code, taskId, characterId, sele
         ws.sendExtensionDone(code, taskId, { error });
     }
 }
+const APP_COLORS = [
+    '#22D3EE', '#A78BFA', '#F472B6', '#34D399', '#FBBF24',
+    '#FB923C', '#60A5FA', '#E879F9', '#2DD4BF', '#F87171',
+];
+/**
+ * Sync apps from the agent's knowledge base.
+ * Reads knowledge items, identifies app-related documents, extracts app info.
+ */
+export async function handleSyncApps(ws, code, taskId, apiUrl, agentToken, agentId) {
+    try {
+        console.log('[sync_apps] Starting knowledge sync...');
+        const knowledgeApi = async (method, apiPath) => {
+            const url = `${apiUrl}${apiPath}`;
+            const res = await fetch(url, {
+                method,
+                headers: {
+                    'Authorization': `Bearer ${agentToken}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            const json = await res.json();
+            if (!res.ok || (json.code && json.code >= 400)) {
+                throw new Error(json.message || `API error: ${res.status}`);
+            }
+            return json.data;
+        };
+        // 1. List all root-level knowledge items
+        const rootData = await knowledgeApi('GET', `/agent-knowledge?agent_id=${agentId}`);
+        const items = rootData.items || [];
+        // 2. Find app-related documents
+        const apps = [];
+        let colorIdx = 0;
+        for (const item of items) {
+            const nameLower = item.name.toLowerCase();
+            const descLower = (item.description || '').toLowerCase();
+            const isApp = nameLower.includes('app') ||
+                descLower.includes('app') ||
+                descLower.includes('application') ||
+                descLower.includes('mobile app') ||
+                descLower.includes('product');
+            if (!isApp)
+                continue;
+            if (item.kind === 'folder') {
+                const folderData = await knowledgeApi('GET', `/agent-knowledge?agent_id=${agentId}&parent_id=${item._id}`);
+                const children = folderData.items || [];
+                const features = [];
+                let appDesc = item.description || '';
+                for (const child of children) {
+                    if (child.kind === 'document') {
+                        const doc = await knowledgeApi('GET', `/agent-knowledge/${child._id}`);
+                        features.push(..._extractFeatures(doc.content || ''));
+                        if (!appDesc && doc.description)
+                            appDesc = doc.description;
+                    }
+                }
+                apps.push({
+                    id: item._id,
+                    name: item.name,
+                    description: appDesc,
+                    features: [...new Set(features)].slice(0, 20),
+                    color: APP_COLORS[colorIdx++ % APP_COLORS.length],
+                });
+            }
+            else if (item.kind === 'document') {
+                const doc = await knowledgeApi('GET', `/agent-knowledge/${item._id}`);
+                apps.push({
+                    id: item._id,
+                    name: item.name,
+                    description: item.description || doc.description || '',
+                    features: [...new Set(_extractFeatures(doc.content || ''))].slice(0, 20),
+                    color: APP_COLORS[colorIdx++ % APP_COLORS.length],
+                });
+            }
+        }
+        console.log(`[sync_apps] Found ${apps.length} app(s)`);
+        ws.sendExtensionEvent(code, {
+            type: 'sync_apps_result',
+            apps,
+        });
+        ws.sendExtensionDone(code, taskId, { ok: true, count: apps.length });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        console.error('[sync_apps] Error:', error);
+        ws.sendExtensionEvent(code, {
+            type: 'sync_apps_result',
+            apps: null,
+            error,
+        });
+        ws.sendExtensionDone(code, taskId, { error });
+    }
+}
+/** Extract feature names from markdown bullet lists or headings. */
+function _extractFeatures(content) {
+    const features = [];
+    const bulletRegex = /^[\s]*[-*]\s+\*{0,2}([^*\n]+)\*{0,2}/gm;
+    let match;
+    while ((match = bulletRegex.exec(content)) !== null) {
+        const feat = match[1].trim().replace(/[:–—].+$/, '').trim();
+        if (feat.length > 2 && feat.length < 60) {
+            features.push(feat);
+        }
+    }
+    if (features.length === 0) {
+        const headingRegex = /^#{2,4}\s+(.+)$/gm;
+        while ((match = headingRegex.exec(content)) !== null) {
+            const feat = match[1].trim();
+            if (feat.length > 2 && feat.length < 60) {
+                features.push(feat);
+            }
+        }
+    }
+    return features;
+}
 function _sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }

package/dist/daemon/index.js

@@ -9,7 +9,7 @@ import { loadPMState, savePMState, clearPMState } from './pm-state.js';
 import { chatWithPM } from '../pm/planner.js';
 import { executePlanAndReport, simplifyMarkdown, waitForInput } from '../utils/execution-helpers.js';
 import { runClaude } from '../utils/claude-cli.js';
-import { handleGetHistory, handleRetryVideo, handleGenerateIdeas, handleGenerateScript, handleGenerateScene, handleGenerateScenes, handleRenderVideo, handleListCharacters, handleCreateCharacter, handleSaveCharacterSelection, } from './extension-handlers.js';
+import { handleGetHistory, handleRetryVideo, handleGenerateIdeas, handleGenerateScript, handleGenerateScene, handleGenerateScenes, handleRenderVideo, handleListCharacters, handleCreateCharacter, handleSaveCharacterSelection, handleSyncApps, } from './extension-handlers.js';
 import { downloadAttachments, cleanupAttachments } from '../utils/image-download.js';
 import { scanSkills } from '../utils/skill-scanner.js';
 import { setupMcpConfig } from '../mcp/setup.js';
@@ -565,6 +565,12 @@ ${skillContent.slice(0, 15000)}`;
                     handleSaveCharacterSelection(ws, extCode, extTaskId, msg.characterId, msg.selectedImages || []);
                     break;
                 }
+                if (extTask === 'sync_apps') {
+                    (async () => {
+                        await handleSyncApps(ws, extCode, extTaskId, config.apiUrl, config.agentToken, config.agentId);
+                    })();
+                    break;
+                }
                 // ── Claude-powered tasks (ideas, script, etc.) ────────────────────────
                 (async () => {
                     try {

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